/* Everything about breakpoints, for GDB.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GDB.
#include "cli/cli-script.h"
#include "gdb_assert.h"
#include "block.h"
+#include "solist.h"
+#include "observer.h"
+#include "exceptions.h"
#include "gdb-events.h"
static int can_use_hardware_watchpoint (struct value *);
-extern void break_at_finish_command (char *, int);
-extern void break_at_finish_at_depth_command (char *, int);
-
-extern void tbreak_at_finish_command (char *, int);
-
-static void break_command_1 (char *, int, int);
+static int break_command_1 (char *, int, int, struct breakpoint *);
static void mention (struct breakpoint *);
static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
-static CORE_ADDR adjust_breakpoint_address (CORE_ADDR bpaddr);
+static CORE_ADDR adjust_breakpoint_address (CORE_ADDR bpaddr,
+ enum bptype bptype);
static void describe_other_breakpoints (CORE_ADDR, asection *);
char *cond_string,
enum bptype bp_kind);
-static void break_at_finish_at_depth_command_1 (char *arg,
- int flag, int from_tty);
-
-static void break_at_finish_command_1 (char *arg, int flag, int from_tty);
-
static void stop_command (char *arg, int from_tty);
static void stopin_command (char *arg, int from_tty);
if such is available. */
static int can_use_hw_watchpoints;
+static void
+show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("\
+Debugger's willingness to use watchpoint hardware is %s.\n"),
+ value);
+}
+
+/* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
+ If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
+ for unrecognized breakpoint locations.
+ If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
+static enum auto_boolean pending_break_support;
+static void
+show_pending_break_support (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("\
+Debugger's behavior regarding pending breakpoints is %s.\n"),
+ value);
+}
+
void _initialize_breakpoint (void);
extern int addressprint; /* Print machine addresses? */
/* Pointer to current exception event record */
static struct exception_event_record *current_exception_event;
-/* Indicator of whether exception catchpoints should be nuked
- between runs of a program */
-int exception_catchpoints_are_fragile = 0;
+/* Indicator of whether exception catchpoints should be nuked between
+ runs of a program. */
+int deprecated_exception_catchpoints_are_fragile = 0;
/* Indicator of when exception catchpoints set-up should be
- reinitialized -- e.g. when program is re-run */
-int exception_support_initialized = 0;
+ reinitialized -- e.g. when program is re-run. */
+int deprecated_exception_support_initialized = 0;
/* This function returns a pointer to the string representation of the
pathname of the dynamically-linked library that has just been
#ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
#define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
- error ("catch of library loads not yet implemented on this platform")
+ error (_("catch of library loads not yet implemented on this platform"))
#endif
/* This function is called by the "catch unload" command. It allows
unloaded. */
#ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
-#define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
- error ("catch of library unloads not yet implemented on this platform")
+#define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
+ error (_("catch of library unloads not yet implemented on this platform"))
#endif
/* Return whether a breakpoint is an active enabled breakpoint. */
static int
breakpoint_enabled (struct breakpoint *b)
{
- return b->enable_state == bp_enabled;
+ return (b->enable_state == bp_enabled && !b->pending);
}
/* Set breakpoint count to NUM. */
strncpy (varname, start, p - start);
varname[p - start] = '\0';
val = value_of_internalvar (lookup_internalvar (varname));
- if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
+ if (TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
retval = (int) value_as_long (val);
else
{
- printf_filtered ("Convenience variable must have integer value.\n");
+ printf_filtered (_("Convenience variable must have integer value.\n"));
retval = 0;
}
}
end_value = get_number (temp);
if (end_value < last_retval)
{
- error ("inverted range");
+ error (_("inverted range"));
}
else if (end_value == last_retval)
{
}
}
else if (! in_range)
- error ("negative value");
+ error (_("negative value"));
else
{
/* pp points to the '-' that betokens a range. All
int bnum;
if (arg == 0)
- error_no_arg ("breakpoint number");
+ error_no_arg (_("breakpoint number"));
p = arg;
bnum = get_number (&p);
if (bnum == 0)
- error ("Bad breakpoint argument: '%s'", arg);
+ error (_("Bad breakpoint argument: '%s'"), arg);
ALL_BREAKPOINTS (b)
if (b->number == bnum)
b->cond = 0;
b->cond_string = NULL;
if (from_tty)
- printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
+ printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum);
}
else
{
/* I don't know if it matters whether this is the string the user
typed in or the decompiled expression. */
b->cond_string = savestring (arg, strlen (arg));
- b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
- if (*arg)
- error ("Junk at end of expression");
+ if (!b->pending)
+ {
+ b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
+ if (*arg)
+ error (_("Junk at end of expression"));
+ }
}
breakpoints_changed ();
breakpoint_modify_event (b->number);
return;
}
- error ("No breakpoint number %d.", bnum);
+ error (_("No breakpoint number %d."), bnum);
}
static void
being read from. */
if (executing_breakpoint_commands)
- error ("Can't use the \"commands\" command among a breakpoint's commands.");
+ error (_("Can't use the \"commands\" command among a breakpoint's commands."));
p = arg;
bnum = get_number (&p);
if (p && *p)
- error ("Unexpected extra arguments following breakpoint number.");
+ error (_("Unexpected extra arguments following breakpoint number."));
ALL_BREAKPOINTS (b)
if (b->number == bnum)
breakpoint_modify_event (b->number);
return;
}
- error ("No breakpoint number %d.", bnum);
+ error (_("No breakpoint number %d."), bnum);
}
\f
/* Like target_read_memory() but if breakpoints are inserted, return
shadow contents, not the breakpoints themselves. From breakpoint.c. */
int
-read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len)
+deprecated_read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len)
{
int status;
struct bp_location *b;
ALL_BP_LOCATIONS (b)
{
if (b->owner->type == bp_none)
- warning ("reading through apparently deleted breakpoint #%d?",
+ warning (_("reading through apparently deleted breakpoint #%d?"),
b->owner->number);
if (b->loc_type != bp_loc_software_breakpoint)
if (bp_addr > memaddr)
{
/* Copy the section of memory before the breakpoint. */
- status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
+ status = deprecated_read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
if (status != 0)
return status;
}
if (bp_addr + bp_size < memaddr + len)
{
/* Copy the section of memory after the breakpoint. */
- status = read_memory_nobpt (bp_addr + bp_size,
+ status = deprecated_read_memory_nobpt (bp_addr + bp_size,
myaddr + bp_addr + bp_size - memaddr,
memaddr + len - (bp_addr + bp_size));
if (status != 0)
\f
/* A wrapper function for inserting catchpoints. */
-static int
+static void
insert_catchpoint (struct ui_out *uo, void *args)
{
struct breakpoint *b = (struct breakpoint *) args;
switch (b->type)
{
case bp_catch_fork:
- val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
+ target_insert_fork_catchpoint (PIDGET (inferior_ptid));
break;
case bp_catch_vfork:
- val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
+ target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
break;
case bp_catch_exec:
- val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
+ target_insert_exec_catchpoint (PIDGET (inferior_ptid));
break;
default:
- internal_error (__FILE__, __LINE__, "unknown breakpoint type");
+ internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
break;
}
+}
- if (val < 0)
- throw_exception (RETURN_ERROR);
+/* Helper routine: free the value chain for a breakpoint (watchpoint). */
- return 0;
+static void free_valchain (struct bp_location *b)
+{
+ struct value *v;
+ struct value *n;
+
+ /* Free the saved value chain. We will construct a new one
+ the next time the watchpoint is inserted. */
+ for (v = b->owner->val_chain; v; v = n)
+ {
+ n = value_next (v);
+ value_free (v);
+ }
+ b->owner->val_chain = NULL;
}
/* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
so we must try to set a breakpoint at the LMA.
This will not work for a hardware breakpoint. */
if (bpt->loc_type == bp_loc_hardware_breakpoint)
- warning ("hardware breakpoint %d not supported in overlay!\n",
+ warning (_("hardware breakpoint %d not supported in overlay!"),
bpt->owner->number);
else
{
bpt->owner->number);
fprintf_filtered (tmp_error_stream,
"Error accessing memory address ");
- print_address_numeric (bpt->address, 1, tmp_error_stream);
+ deprecated_print_address_numeric (bpt->address, 1, tmp_error_stream);
fprintf_filtered (tmp_error_stream, ": %s.\n",
safe_strerror (val));
}
must watch. As soon as a many-to-one mapping is available I'll
convert this. */
- struct frame_info *saved_frame;
- int saved_level, within_current_scope;
+ int within_current_scope;
struct value *mark = value_mark ();
struct value *v;
+ struct frame_id saved_frame_id;
- /* Save the current frame and level so we can restore it after
+ /* Save the current frame's ID so we can restore it after
evaluating the watchpoint expression on its own frame. */
/* FIXME drow/2003-09-09: It would be nice if evaluate_expression
took a frame parameter, so that we didn't have to change the
selected frame. */
- saved_frame = deprecated_selected_frame;
- saved_level = frame_relative_level (deprecated_selected_frame);
+ saved_frame_id = get_frame_id (deprecated_selected_frame);
/* Determine if the watchpoint is within scope. */
if (bpt->owner->exp_valid_block == NULL)
if (within_current_scope)
{
+ free_valchain (bpt);
+
/* Evaluate the expression and cut the chain of values
produced off from the value chain.
laziness to determine what memory GDB actually needed
in order to compute the value of the expression. */
v = evaluate_expression (bpt->owner->exp);
- VALUE_CONTENTS (v);
+ value_contents (v);
value_release_to_mark (mark);
bpt->owner->val_chain = v;
bpt->inserted = 1;
/* Look at each value on the value chain. */
- for (; v; v = v->next)
+ for (; v; v = value_next (v))
{
/* If it's a memory location, and GDB actually needed
its contents to evaluate the expression, then we
must watch it. */
if (VALUE_LVAL (v) == lval_memory
- && ! VALUE_LAZY (v))
+ && ! value_lazy (v))
{
- struct type *vtype = check_typedef (VALUE_TYPE (v));
+ struct type *vtype = check_typedef (value_type (v));
/* We only watch structs and arrays if user asked
for it explicitly, never if they just happen to
CORE_ADDR addr;
int len, type;
- addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
- len = TYPE_LENGTH (VALUE_TYPE (v));
+ addr = VALUE_ADDRESS (v) + value_offset (v);
+ len = TYPE_LENGTH (value_type (v));
type = hw_write;
if (bpt->owner->type == bp_read_watchpoint)
type = hw_read;
}
else
{
- printf_filtered ("Hardware watchpoint %d deleted ", bpt->owner->number);
- printf_filtered ("because the program has left the block \n");
- printf_filtered ("in which its expression is valid.\n");
+ printf_filtered (_("\
+Hardware watchpoint %d deleted because the program has left the block \n\
+in which its expression is valid.\n"),
+ bpt->owner->number);
if (bpt->owner->related_breakpoint)
bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop;
bpt->owner->disposition = disp_del_at_next_stop;
}
- /* Restore the frame and level. */
- if (saved_frame != deprecated_selected_frame
- || saved_level != frame_relative_level (deprecated_selected_frame))
- select_frame (saved_frame);
+ /* Restore the selected frame. */
+ select_frame (frame_find_by_id (saved_frame_id));
return val;
}
bpt->owner->number);
fprintf_filtered (tmp_error_stream,
"Error accessing memory address ");
- print_address_numeric (bpt->address, 1, tmp_error_stream);
+ deprecated_print_address_numeric (bpt->address, 1, tmp_error_stream);
fprintf_filtered (tmp_error_stream, ": %s.\n",
safe_strerror (val));
bpt->owner->enable_state = bp_disabled;
|| bpt->owner->type == bp_catch_vfork
|| bpt->owner->type == bp_catch_exec)
{
- char *prefix = xstrprintf ("warning: inserting catchpoint %d: ",
- bpt->owner->number);
- struct cleanup *cleanups = make_cleanup (xfree, prefix);
- val = catch_exceptions (uiout, insert_catchpoint, bpt->owner, prefix,
- RETURN_MASK_ERROR);
- do_cleanups (cleanups);
- if (val < 0)
+ struct gdb_exception e = catch_exception (uiout, insert_catchpoint,
+ bpt->owner, RETURN_MASK_ERROR);
+ exception_fprintf (gdb_stderr, e, "warning: inserting catchpoint %d: ",
+ bpt->owner->number);
+ if (e.reason < 0)
bpt->owner->enable_state = bp_disabled;
else
bpt->inserted = 1;
struct value *val;
val = evaluate_expression (b->owner->exp);
release_value (val);
- if (VALUE_LAZY (val))
+ if (value_lazy (val))
value_fetch_lazy (val);
b->owner->val = val;
}
struct cleanup *old_chain = save_inferior_ptid ();
if (pid == PIDGET (inferior_ptid))
- error ("Cannot detach breakpoints of inferior_ptid");
+ error (_("Cannot detach breakpoints of inferior_ptid"));
/* Set inferior_ptid; remove_breakpoint uses this global. */
inferior_ptid = pid_to_ptid (pid);
return 0;
if (b->owner->type == bp_none)
- warning ("attempted to remove apparently deleted breakpoint #%d?",
+ warning (_("attempted to remove apparently deleted breakpoint #%d?"),
b->owner->number);
if (b->loc_type == bp_loc_software_breakpoint
b->inserted = (is == mark_inserted);
/* Walk down the saved value chain. */
- for (v = b->owner->val_chain; v; v = v->next)
+ for (v = b->owner->val_chain; v; v = value_next (v))
{
/* For each memory reference remove the watchpoint
at that address. */
if (VALUE_LVAL (v) == lval_memory
- && ! VALUE_LAZY (v))
+ && ! value_lazy (v))
{
- struct type *vtype = check_typedef (VALUE_TYPE (v));
+ struct type *vtype = check_typedef (value_type (v));
if (v == b->owner->val_chain
|| (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
CORE_ADDR addr;
int len, type;
- addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
- len = TYPE_LENGTH (VALUE_TYPE (v));
+ addr = VALUE_ADDRESS (v) + value_offset (v);
+ len = TYPE_LENGTH (value_type (v));
type = hw_write;
if (b->owner->type == bp_read_watchpoint)
type = hw_read;
}
/* Failure to remove any of the hardware watchpoints comes here. */
if ((is == mark_uninserted) && (b->inserted))
- warning ("Could not remove hardware watchpoint %d.",
+ warning (_("Could not remove hardware watchpoint %d."),
b->owner->number);
-
- /* Free the saved value chain. We will construct a new one
- the next time the watchpoint is inserted. */
- for (v = b->owner->val_chain; v; v = n)
- {
- n = v->next;
- value_free (v);
- }
- b->owner->val_chain = NULL;
}
else if ((b->owner->type == bp_catch_fork ||
b->owner->type == bp_catch_vfork ||
val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
break;
default:
- warning ("Internal error, %s line %d.", __FILE__, __LINE__);
+ warning (_("Internal error, %s line %d."), __FILE__, __LINE__);
break;
}
if (val)
default:
/* Likewise for exception catchpoints in dynamic-linked
executables where required */
- if (ep_is_exception_catchpoint (b) &&
- exception_catchpoints_are_fragile)
+ if (ep_is_exception_catchpoint (b)
+ && deprecated_exception_catchpoints_are_fragile)
{
warning_needed = 1;
delete_breakpoint (b);
}
}
- if (exception_catchpoints_are_fragile)
- exception_support_initialized = 0;
+ if (deprecated_exception_catchpoints_are_fragile)
+ deprecated_exception_support_initialized = 0;
/* Don't issue the warning unless it's really needed... */
if (warning_needed && (context != inf_exited))
{
- warning ("Exception catchpoints from last run were deleted.");
- warning ("You must reinsert them explicitly.");
+ warning (_("Exception catchpoints from last run were deleted.\n"
+ "You must reinsert them explicitly."));
warning_needed = 0;
}
}
return 0;
}
-/* Return nonzero if FRAME is a dummy frame. We can't use
- DEPRECATED_PC_IN_CALL_DUMMY because figuring out the saved SP would
- take too much time, at least using frame_register() on the 68k.
- This means that for this function to work right a port must use the
- bp_call_dummy breakpoint. */
-
-int
-deprecated_frame_in_dummy (struct frame_info *frame)
-{
- struct breakpoint *b;
-
- /* This function is used by two files: get_frame_type(), after first
- checking that !DEPRECATED_USE_GENERIC_DUMMY_FRAMES; and
- sparc-tdep.c, which doesn't yet use generic dummy frames anyway. */
- gdb_assert (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
-
- ALL_BREAKPOINTS (b)
- {
- if (b->type == bp_call_dummy
- && frame_id_eq (b->frame_id, get_frame_id (frame))
- /* We need to check the PC as well as the frame on the sparc,
- for signals.exp in the testsuite. */
- && (get_frame_pc (frame)
- >= (b->loc->address
- - DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * DEPRECATED_REGISTER_SIZE))
- && get_frame_pc (frame) <= b->loc->address)
- return 1;
- }
- return 0;
-}
-
/* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
PC is valid for process/thread PTID. */
{
int current_thread;
- if (bsp == NULL)
- error ("Internal error (bpstat_find_step_resume_breakpoint)");
+ gdb_assert (bsp != NULL);
current_thread = pid_to_thread_id (inferior_ptid);
return bsp->breakpoint_at;
}
- error ("Internal error (no step_resume breakpoint found)");
+ internal_error (__FILE__, __LINE__, _("No step_resume breakpoint found."));
}
/* Did we stop because the user set the stop_on_solib_events
variable? (If so, we report this as a generic, "Stopped due
to shlib event" message.) */
- printf_filtered ("Stopped due to shared library event\n");
+ printf_filtered (_("Stopped due to shared library event\n"));
return PRINT_NOTHING;
break;
case bp_thread_event:
/* Not sure how we will get here.
GDB should not stop for these breakpoints. */
- printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
+ printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
return PRINT_NOTHING;
break;
case bp_overlay_event:
/* By analogy with the thread event, GDB should not stop for these. */
- printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
+ printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
return PRINT_NOTHING;
break;
case bp_catch_load:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("loaded");
- printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
+ printf_filtered (_("\nCatchpoint %d (loaded %s), "),
+ bs->breakpoint_at->number,
+ bs->breakpoint_at->triggered_dll_pathname);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_unload:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("unloaded");
- printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
+ printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
+ bs->breakpoint_at->number,
+ bs->breakpoint_at->triggered_dll_pathname);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_fork:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("forked");
- printf_filtered (" process %d), ",
+ printf_filtered (_("\nCatchpoint %d (forked process %d), "),
+ bs->breakpoint_at->number,
bs->breakpoint_at->forked_inferior_pid);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_vfork:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
- printf_filtered ("vforked");
- printf_filtered (" process %d), ",
+ printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
+ bs->breakpoint_at->number,
bs->breakpoint_at->forked_inferior_pid);
return PRINT_SRC_AND_LOC;
break;
case bp_catch_exec:
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (exec'd %s), ",
+ printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
bs->breakpoint_at->number,
bs->breakpoint_at->exec_pathname);
return PRINT_SRC_AND_LOC;
(CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
{
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (exception caught), ",
+ printf_filtered (_("\nCatchpoint %d (exception caught), "),
bs->breakpoint_at->number);
- printf_filtered ("throw location ");
if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("throw location %s:%d, "),
CURRENT_EXCEPTION_THROW_FILE,
CURRENT_EXCEPTION_THROW_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("throw location unknown, "));
- printf_filtered (", catch location ");
if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("catch location %s:%d\n"),
CURRENT_EXCEPTION_CATCH_FILE,
CURRENT_EXCEPTION_CATCH_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("catch location unknown\n"));
- printf_filtered ("\n");
/* don't bother to print location frame info */
return PRINT_SRC_ONLY;
}
(CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
{
annotate_catchpoint (bs->breakpoint_at->number);
- printf_filtered ("\nCatchpoint %d (exception thrown), ",
+ printf_filtered (_("\nCatchpoint %d (exception thrown), "),
bs->breakpoint_at->number);
- printf_filtered ("throw location ");
if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("throw location %s:%d, "),
CURRENT_EXCEPTION_THROW_FILE,
CURRENT_EXCEPTION_THROW_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("throw location unknown, "));
- printf_filtered (", catch location ");
if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
- printf_filtered ("%s:%d",
+ printf_filtered (_("catch location %s:%d\n"),
CURRENT_EXCEPTION_CATCH_FILE,
CURRENT_EXCEPTION_CATCH_LINE);
else
- printf_filtered ("unknown");
+ printf_filtered (_("catch location unknown\n"));
- printf_filtered ("\n");
/* don't bother to print location frame info */
return PRINT_SRC_ONLY;
}
default:
internal_error (__FILE__, __LINE__,
- "print_bp_stop_message: unrecognized enum value");
+ _("print_bp_stop_message: unrecognized enum value"));
break;
}
}
}
}
-/* Get a bpstat associated with having just stopped at address *PC
- and frame address CORE_ADDRESS. Update *PC to point at the
- breakpoint (if we hit a breakpoint). NOT_A_SW_BREAKPOINT is nonzero
- if this is known to not be a real breakpoint (it could still be a
- watchpoint, though). */
+/* Get a bpstat associated with having just stopped at address
+ BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
+ target thinks we stopped due to a hardware watchpoint, 0 if we
+ know we did not trigger a hardware watchpoint, and -1 if we do not know. */
/* Determine whether we stopped at a breakpoint, etc, or whether we
don't understand this stop. Result is a chain of bpstat's such that:
commands, FIXME??? fields. */
bpstat
-bpstat_stop_status (CORE_ADDR *pc, int not_a_sw_breakpoint)
+bpstat_stop_status (CORE_ADDR bp_addr, ptid_t ptid, int stopped_by_watchpoint)
{
struct breakpoint *b, *temp;
- CORE_ADDR bp_addr;
/* True if we've hit a breakpoint (as opposed to a watchpoint). */
int real_breakpoint = 0;
/* Root of the chain of bpstat's */
struct bpstats root_bs[1];
/* Pointer to the last thing in the chain currently. */
bpstat bs = root_bs;
-
- bp_addr = *pc;
+ int thread_id = pid_to_thread_id (ptid);
ALL_BREAKPOINTS_SAFE (b, temp)
{
continue;
}
+ /* Continuable hardware watchpoints are treated as non-existent if the
+ reason we stopped wasn't a hardware watchpoint (we didn't stop on
+ some data address). Otherwise gdb won't stop on a break instruction
+ in the code (not from a breakpoint) when a hardware watchpoint has
+ been defined. */
+
+ if ((b->type == bp_hardware_watchpoint
+ || b->type == bp_read_watchpoint
+ || b->type == bp_access_watchpoint)
+ && !stopped_by_watchpoint)
+ continue;
+
if (b->type == bp_hardware_breakpoint)
{
- if (b->loc->address != *pc)
+ if (b->loc->address != bp_addr)
continue;
if (overlay_debugging /* unmapped overlay section */
&& section_is_overlay (b->loc->section)
/* FALLTHROUGH */
case 0:
/* Error from catch_errors. */
- printf_filtered ("Watchpoint %d deleted.\n", b->number);
+ printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
if (b->related_breakpoint)
b->related_breakpoint->disposition = disp_del_at_next_stop;
b->disposition = disp_del_at_next_stop;
struct value *v;
int found = 0;
- addr = target_stopped_data_address ();
- if (addr == 0)
+ if (!target_stopped_data_address (¤t_target, &addr))
continue;
- for (v = b->val_chain; v; v = v->next)
+ for (v = b->val_chain; v; v = value_next (v))
{
if (VALUE_LVAL (v) == lval_memory
- && ! VALUE_LAZY (v))
+ && ! value_lazy (v))
{
- struct type *vtype = check_typedef (VALUE_TYPE (v));
+ struct type *vtype = check_typedef (value_type (v));
if (v == b->val_chain
|| (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
{
CORE_ADDR vaddr;
- vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
+ vaddr = VALUE_ADDRESS (v) + value_offset (v);
/* Exact match not required. Within range is
sufficient. */
if (addr >= vaddr &&
- addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v)))
+ addr < vaddr + TYPE_LENGTH (value_type (v)))
found = 1;
}
}
/* Can't happen. */
case 0:
/* Error from catch_errors. */
- printf_filtered ("Watchpoint %d deleted.\n", b->number);
+ printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
if (b->related_breakpoint)
b->related_breakpoint->disposition = disp_del_at_next_stop;
b->disposition = disp_del_at_next_stop;
/* Don't consider this a hit. */
--(b->hit_count);
}
+ else if (b->thread != -1 && b->thread != thread_id)
+ {
+ bs->stop = 0;
+ /* Don't consider this a hit. */
+ --(b->hit_count);
+ }
else if (b->ignore_count > 0)
{
b->ignore_count--;
/* step_resume entries: a step resume breakpoint overrides another
breakpoint of signal handling (see comment in wait_for_inferior
- at first PC_IN_SIGTRAMP where we set the step_resume breakpoint). */
+ at where we set the step_resume breakpoint). */
/* We handle the through_sigtramp_breakpoint the same way; having both
one of those and a step_resume_breakpoint is probably very rare (?). */
if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
|| ((int) b->type != bptypes[(int) b->type].type))
internal_error (__FILE__, __LINE__,
- "bptypes table does not describe type #%d.",
+ _("bptypes table does not describe type #%d."),
(int) b->type);
ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
{
case bp_none:
internal_error (__FILE__, __LINE__,
- "print_one_breakpoint: bp_none encountered\n");
+ _("print_one_breakpoint: bp_none encountered\n"));
break;
case bp_watchpoint:
if (addressprint)
{
annotate_field (4);
- ui_out_field_core_addr (uiout, "addr", b->loc->address);
+ if (b->pending)
+ ui_out_field_string (uiout, "addr", "<PENDING>");
+ else
+ ui_out_field_core_addr (uiout, "addr", b->loc->address);
}
annotate_field (5);
*last_addr = b->loc->address;
ui_out_text (uiout, ":");
ui_out_field_int (uiout, "line", b->line_number);
}
+ else if (b->pending)
+ {
+ ui_out_field_string (uiout, "pending", b->addr_string);
+ }
else
{
print_address_symbolic (b->loc->address, stb->stream, demangle, "");
ui_out_field_stream (uiout, "cond", stb);
ui_out_text (uiout, "\n");
}
-
+
+ if (b->pending && b->cond_string)
+ {
+ annotate_field (7);
+ ui_out_text (uiout, "\tstop only if ");
+ ui_out_field_string (uiout, "cond", b->cond_string);
+ ui_out_text (uiout, "\n");
+ }
+
if (b->thread != -1)
{
/* FIXME should make an annotation for this */
}
enum gdb_rc
-gdb_breakpoint_query (struct ui_out *uiout, int bnum)
+gdb_breakpoint_query (struct ui_out *uiout, int bnum, char **error_message)
{
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_exceptions (uiout, do_captured_breakpoint_query, &args,
- NULL, RETURN_MASK_ALL);
+ return catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
+ error_message, RETURN_MASK_ALL);
}
/* Return non-zero if B is user settable (breakpoints, watchpoints,
ALL_BREAKPOINTS (b)
if (b->loc->address == pc) /* address match / overlay match */
- if (!overlay_debugging || b->loc->section == section)
+ if (!b->pending && (!overlay_debugging || b->loc->section == section))
others++;
if (others > 0)
{
- printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
+ if (others == 1)
+ printf_filtered (_("Note: breakpoint "));
+ else /* if (others == ???) */
+ printf_filtered (_("Note: breakpoints "));
ALL_BREAKPOINTS (b)
if (b->loc->address == pc) /* address match / overlay match */
- if (!overlay_debugging || b->loc->section == section)
+ if (!b->pending && (!overlay_debugging || b->loc->section == section))
{
others--;
printf_filtered ("%d%s%s ",
(others > 1) ? ","
: ((others == 1) ? " and" : ""));
}
- printf_filtered ("also set at pc ");
- print_address_numeric (pc, 1, gdb_stdout);
+ printf_filtered (_("also set at pc "));
+ deprecated_print_address_numeric (pc, 1, gdb_stdout);
printf_filtered (".\n");
}
}
ALL_BP_LOCATIONS (b)
if (b->owner->enable_state != bp_disabled
&& b->owner->enable_state != bp_shlib_disabled
+ && !b->owner->pending
&& b->owner->enable_state != bp_call_disabled
&& b->address == address /* address / overlay match */
&& (!overlay_debugging || b->section == section)
/* Permanent breakpoint should always be inserted. */
if (! perm_bp->inserted)
internal_error (__FILE__, __LINE__,
- "allegedly permanent breakpoint is not "
- "actually inserted");
+ _("allegedly permanent breakpoint is not "
+ "actually inserted"));
ALL_BP_LOCATIONS (b)
if (b != perm_bp)
{
if (b->owner->enable_state != bp_disabled
&& b->owner->enable_state != bp_shlib_disabled
+ && !b->owner->pending
&& b->owner->enable_state != bp_call_disabled
&& b->address == address /* address / overlay match */
&& (!overlay_debugging || b->section == section)
{
if (b->inserted)
internal_error (__FILE__, __LINE__,
- "another breakpoint was inserted on top of "
- "a permanent breakpoint");
+ _("another breakpoint was inserted on top of "
+ "a permanent breakpoint"));
b->duplicate = 1;
}
char astr1[40];
char astr2[40];
- strcpy (astr1, local_hex_string_custom ((unsigned long) from_addr, "08l"));
- strcpy (astr2, local_hex_string_custom ((unsigned long) to_addr, "08l"));
+ strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
+ strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
if (have_bnum)
- warning ("Breakpoint %d address previously adjusted from %s to %s.",
+ warning (_("Breakpoint %d address previously adjusted from %s to %s."),
bnum, astr1, astr2);
else
- warning ("Breakpoint address adjusted from %s to %s.", astr1, astr2);
+ warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
}
/* Adjust a breakpoint's address to account for architectural constraints
this function is simply the identity function. */
static CORE_ADDR
-adjust_breakpoint_address (CORE_ADDR bpaddr)
+adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype)
{
if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch))
{
/* Very few targets need any kind of breakpoint adjustment. */
return bpaddr;
}
+ else if (bptype == bp_watchpoint
+ || bptype == bp_hardware_watchpoint
+ || bptype == bp_read_watchpoint
+ || bptype == bp_access_watchpoint
+ || bptype == bp_catch_fork
+ || bptype == bp_catch_vfork
+ || bptype == bp_catch_exec)
+ {
+ /* Watchpoints and the various bp_catch_* eventpoints should not
+ have their addresses modified. */
+ return bpaddr;
+ }
else
{
CORE_ADDR adjusted_bpaddr;
loc->loc_type = bp_loc_other;
break;
default:
- internal_error (__FILE__, __LINE__, "unknown breakpoint type");
+ internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
}
/* Add this breakpoint to the end of the chain. */
memset (b, 0, sizeof (*b));
b->loc = allocate_bp_location (b, bptype);
b->loc->requested_address = sal.pc;
- b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
+ b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
+ bptype);
if (sal.symtab == NULL)
b->source_file = NULL;
else
b->forked_inferior_pid = 0;
b->exec_pathname = NULL;
b->ops = NULL;
+ b->pending = 0;
/* Add this breakpoint to the end of the chain
so that a list of breakpoints will come out in order
b->enable_state = bp_enabled;
/* addr_string has to be used or breakpoint_re_set will delete me. */
- xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
+ b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
return b;
}
delete_breakpoint (b);
}
+struct captured_parse_breakpoint_args
+ {
+ char **arg_p;
+ struct symtabs_and_lines *sals_p;
+ char ***addr_string_p;
+ int *not_found_ptr;
+ };
+
+struct lang_and_radix
+ {
+ enum language lang;
+ int radix;
+ };
+
+/* Cleanup helper routine to restore the current language and
+ input radix. */
+static void
+do_restore_lang_radix_cleanup (void *old)
+{
+ struct lang_and_radix *p = old;
+ set_language (p->lang);
+ input_radix = p->radix;
+}
+
+/* Try and resolve a pending breakpoint. */
+static int
+resolve_pending_breakpoint (struct breakpoint *b)
+{
+ /* Try and reparse the breakpoint in case the shared library
+ is now loaded. */
+ struct symtabs_and_lines sals;
+ struct symtab_and_line pending_sal;
+ char **cond_string = (char **) NULL;
+ char *copy_arg = b->addr_string;
+ char **addr_string;
+ char *errmsg;
+ int rc;
+ int not_found = 0;
+ struct ui_file *old_gdb_stderr;
+ struct lang_and_radix old_lr;
+ struct cleanup *old_chain;
+
+ /* Set language, input-radix, then reissue breakpoint command.
+ Ensure the language and input-radix are restored afterwards. */
+ old_lr.lang = current_language->la_language;
+ old_lr.radix = input_radix;
+ old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr);
+
+ set_language (b->language);
+ input_radix = b->input_radix;
+ rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b);
+
+ if (rc == GDB_RC_OK)
+ /* Pending breakpoint has been resolved. */
+ printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b->addr_string);
+
+ do_cleanups (old_chain);
+ return rc;
+}
+
#ifdef SOLIB_ADD
void
remove_solib_event_breakpoints (void)
if (!disabled_shlib_breaks)
{
target_terminal_ours_for_output ();
- warning ("Temporarily disabling shared library breakpoints:");
+ warning (_("Temporarily disabling shared library breakpoints:"));
}
disabled_shlib_breaks = 1;
- warning ("breakpoint #%d ", b->number);
+ warning (_("breakpoint #%d "), b->number);
}
}
#endif
}
}
-/* Try to reenable any breakpoints in shared libraries. */
+/* Disable any breakpoints that are in in an unloaded shared library. Only
+ apply to enabled breakpoints, disabled ones can just stay disabled. */
+
void
-re_enable_breakpoints_in_shlibs (void)
+disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
{
struct breakpoint *b;
+ int disabled_shlib_breaks = 0;
+#if defined (PC_SOLIB)
+ /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
ALL_BREAKPOINTS (b)
- if (b->enable_state == bp_shlib_disabled)
- {
- char buf[1], *lib;
+ {
+ if ((b->loc->loc_type == bp_loc_hardware_breakpoint
+ || b->loc->loc_type == bp_loc_software_breakpoint)
+ && breakpoint_enabled (b)
+ && !b->loc->duplicate)
+ {
+ char *so_name = PC_SOLIB (b->loc->address);
+ if (so_name
+ && !strcmp (so_name, solib->so_name))
+ {
+ b->enable_state = bp_shlib_disabled;
+ /* At this point, we cannot rely on remove_breakpoint
+ succeeding so we must mark the breakpoint as not inserted
+ to prevent future errors occurring in remove_breakpoints. */
+ b->loc->inserted = 0;
+ if (!disabled_shlib_breaks)
+ {
+ target_terminal_ours_for_output ();
+ warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
+ so_name);
+ }
+ disabled_shlib_breaks = 1;
+ }
+ }
+ }
+#endif
+}
- /* Do not reenable the breakpoint if the shared library
- is still not mapped in. */
- lib = PC_SOLIB (b->loc->address);
- if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
- b->enable_state = bp_enabled;
- }
+/* Try to reenable any breakpoints in shared libraries. */
+void
+re_enable_breakpoints_in_shlibs (void)
+{
+ struct breakpoint *b, *tmp;
+
+ ALL_BREAKPOINTS_SAFE (b, tmp)
+ {
+ if (b->enable_state == bp_shlib_disabled)
+ {
+ char buf[1], *lib;
+
+ /* Do not reenable the breakpoint if the shared library
+ is still not mapped in. */
+ lib = PC_SOLIB (b->loc->address);
+ if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
+ b->enable_state = bp_enabled;
+ }
+ else if (b->pending && (b->enable_state == bp_enabled))
+ {
+ if (resolve_pending_breakpoint (b) == GDB_RC_OK)
+ delete_breakpoint (b);
+ }
+ }
}
#endif
char **canonical = (char **) NULL;
int thread = -1; /* All threads. */
- /* Set a breakpoint on the specified hook. */
- sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical, NULL);
+ /* Set a breakpoint on the specified hook. */
+ sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL,
+ 0, &canonical, NULL);
addr_end = hookname;
if (sals.nelts == 0)
{
- warning ("Unable to set a breakpoint on dynamic linker callback.");
- warning ("Suggest linking with /opt/langtools/lib/end.o.");
- warning ("GDB will be unable to track shl_load/shl_unload calls");
+ warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
+ "Suggest linking with /opt/langtools/lib/end.o.\n"
+ "GDB will be unable to track shl_load/shl_unload calls."));
return;
}
if (sals.nelts != 1)
{
- warning ("Unable to set unique breakpoint on dynamic linker callback.");
- warning ("GDB will be unable to track shl_load/shl_unload calls");
+ warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
+ "GDB will be unable to track shl_load/shl_unload calls."));
return;
}
create_solib_unload_event_breakpoint (char *hookname, int tempflag,
char *dll_pathname, char *cond_string)
{
- solib_load_unload_1 (hookname,tempflag, dll_pathname,
+ solib_load_unload_1 (hookname, tempflag, dll_pathname,
cond_string, bp_catch_unload);
}
if (b->type == bp_longjmp_resume)
{
b->loc->requested_address = pc;
- b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
+ b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
+ b->type);
b->enable_state = bp_enabled;
b->frame_id = frame_id;
check_duplicates (b);
stb = ui_out_stream_new (uiout);
old_chain = make_cleanup_ui_out_stream_delete (stb);
- /* FIXME: This is misplaced; mention() is called by things (like hitting a
- watchpoint) other than breakpoint creation. It should be possible to
- clean this up and at the same time replace the random calls to
- breakpoint_changed with this hook, as has already been done for
- delete_breakpoint_hook and so on. */
- if (create_breakpoint_hook)
- create_breakpoint_hook (b);
+ /* FIXME: This is misplaced; mention() is called by things (like
+ hitting a watchpoint) other than breakpoint creation. It should
+ be possible to clean this up and at the same time replace the
+ random calls to breakpoint_changed with this hook, as has already
+ been done for deprecated_delete_breakpoint_hook and so on. */
+ if (deprecated_create_breakpoint_hook)
+ deprecated_create_breakpoint_hook (b);
breakpoint_create_event (b->number);
if (b->ops != NULL && b->ops->print_mention != NULL)
switch (b->type)
{
case bp_none:
- printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
+ printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b->number);
break;
case bp_watchpoint:
ui_out_text (uiout, "Watchpoint ");
say_where = 0;
break;
}
- printf_filtered ("Breakpoint %d", b->number);
+ printf_filtered (_("Breakpoint %d"), b->number);
say_where = 1;
break;
case bp_hardware_breakpoint:
say_where = 0;
break;
}
- printf_filtered ("Hardware assisted breakpoint %d", b->number);
+ printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
say_where = 1;
break;
case bp_catch_load:
case bp_catch_unload:
- printf_filtered ("Catchpoint %d (%s %s)",
+ printf_filtered (_("Catchpoint %d (%s %s)"),
b->number,
(b->type == bp_catch_load) ? "load" : "unload",
(b->dll_pathname != NULL) ?
break;
case bp_catch_fork:
case bp_catch_vfork:
- printf_filtered ("Catchpoint %d (%s)",
+ printf_filtered (_("Catchpoint %d (%s)"),
b->number,
(b->type == bp_catch_fork) ? "fork" : "vfork");
break;
case bp_catch_exec:
- printf_filtered ("Catchpoint %d (exec)",
+ printf_filtered (_("Catchpoint %d (exec)"),
b->number);
break;
case bp_catch_catch:
case bp_catch_throw:
- printf_filtered ("Catchpoint %d (%s)",
+ printf_filtered (_("Catchpoint %d (%s)"),
b->number,
(b->type == bp_catch_catch) ? "catch" : "throw");
break;
if (say_where)
{
- if (addressprint || b->source_file == NULL)
+ /* i18n: cagney/2005-02-11: Below needs to be merged into a
+ single string. */
+ if (b->pending)
{
- printf_filtered (" at ");
- print_address_numeric (b->loc->address, 1, gdb_stdout);
+ printf_filtered (_(" (%s) pending."), b->addr_string);
+ }
+ else
+ {
+ if (addressprint || b->source_file == NULL)
+ {
+ printf_filtered (" at ");
+ deprecated_print_address_numeric (b->loc->address, 1, gdb_stdout);
+ }
+ if (b->source_file)
+ printf_filtered (": file %s, line %d.",
+ b->source_file, b->line_number);
}
- if (b->source_file)
- printf_filtered (": file %s, line %d.",
- b->source_file, b->line_number);
}
do_cleanups (old_chain);
if (ui_out_is_mi_like_p (uiout))
SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
COND[i] and COND_STRING[i] values.
+ The parameter PENDING_BP points to a pending breakpoint that is
+ the basis of the breakpoints currently being created. The pending
+ breakpoint may contain a separate condition string or commands
+ that were added after the initial pending breakpoint was created.
+
NOTE: If the function succeeds, the caller is expected to cleanup
the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
array contents). If the function fails (error() is called), the
create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
struct expression **cond, char **cond_string,
enum bptype type, enum bpdisp disposition,
- int thread, int ignore_count, int from_tty)
+ int thread, int ignore_count, int from_tty,
+ struct breakpoint *pending_bp)
{
if (type == bp_hardware_breakpoint)
{
TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
i + sals.nelts, 0);
if (target_resources_ok == 0)
- error ("No hardware breakpoint support in the target.");
+ error (_("No hardware breakpoint support in the target."));
else if (target_resources_ok < 0)
- error ("Hardware breakpoints used exceeds limit.");
+ error (_("Hardware breakpoints used exceeds limit."));
}
/* Now set all the breakpoints. */
else
/* addr_string has to be used or breakpoint_re_set will delete
me. */
- xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
+ b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
b->cond_string = cond_string[i];
b->ignore_count = ignore_count;
b->enable_state = bp_enabled;
b->disposition = disposition;
+ /* If resolving a pending breakpoint, a check must be made to see if
+ the user has specified a new condition or commands for the
+ breakpoint. A new condition will override any condition that was
+ initially specified with the initial breakpoint command. */
+ if (pending_bp)
+ {
+ char *arg;
+ if (pending_bp->cond_string)
+ {
+ arg = pending_bp->cond_string;
+ b->cond_string = savestring (arg, strlen (arg));
+ b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
+ if (*arg)
+ error (_("Junk at end of pending breakpoint condition expression"));
+ }
+ /* If there are commands associated with the breakpoint, they should
+ be copied too. */
+ if (pending_bp->commands)
+ b->commands = copy_command_lines (pending_bp->commands);
+
+ /* We have to copy over the ignore_count and thread as well. */
+ b->ignore_count = pending_bp->ignore_count;
+ b->thread = pending_bp->thread;
+ }
mention (b);
}
}
static void
parse_breakpoint_sals (char **address,
struct symtabs_and_lines *sals,
- char ***addr_string)
+ char ***addr_string,
+ int *not_found_ptr)
{
char *addr_start = *address;
*addr_string = NULL;
sals->nelts = 1;
}
else
- error ("No default breakpoint address now.");
+ error (_("No default breakpoint address now."));
}
else
{
|| ((strchr ("+-", (*address)[0]) != NULL)
&& ((*address)[1] != '['))))
*sals = decode_line_1 (address, 1, default_breakpoint_symtab,
- default_breakpoint_line, addr_string, NULL);
+ default_breakpoint_line, addr_string,
+ not_found_ptr);
else
- *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0, addr_string, NULL);
+ *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
+ addr_string, not_found_ptr);
}
/* For any SAL that didn't have a canonical string, fill one in. */
if (sals->nelts > 0 && *addr_string == NULL)
Give the target a chance to bless sals.sals[i].pc before we
try to make a breakpoint for it. */
- if (PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
+#ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
+ if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
{
if (address == NULL)
- error ("Cannot break without a running program.");
+ error (_("Cannot break without a running program."));
else
- error ("Cannot break on %s without a running program.",
+ error (_("Cannot break on %s without a running program."),
address);
}
+#endif
}
}
+static void
+do_captured_parse_breakpoint (struct ui_out *ui, void *data)
+{
+ struct captured_parse_breakpoint_args *args = data;
+
+ parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p,
+ args->not_found_ptr);
+}
+
/* Set a breakpoint according to ARG (function, linenum or *address)
flag: first bit : 0 non-temporary, 1 temporary.
- second bit : 0 normal breakpoint, 1 hardware breakpoint. */
+ second bit : 0 normal breakpoint, 1 hardware breakpoint.
-static void
-break_command_1 (char *arg, int flag, int from_tty)
+ PENDING_BP is non-NULL when this function is being called to resolve
+ a pending breakpoint. */
+
+static int
+break_command_1 (char *arg, int flag, int from_tty, struct breakpoint *pending_bp)
{
+ struct gdb_exception e;
int tempflag, hardwareflag;
struct symtabs_and_lines sals;
struct expression **cond = 0;
- /* Pointers in arg to the start, and one past the end, of the
- condition. */
+ struct symtab_and_line pending_sal;
char **cond_string = (char **) NULL;
+ char *copy_arg;
+ char *err_msg;
char *addr_start = arg;
char **addr_string;
struct cleanup *old_chain;
struct cleanup *breakpoint_chain = NULL;
+ struct captured_parse_breakpoint_args parse_args;
int i;
+ int pending = 0;
int thread = -1;
int ignore_count = 0;
+ int not_found = 0;
hardwareflag = flag & BP_HARDWAREFLAG;
tempflag = flag & BP_TEMPFLAG;
sals.sals = NULL;
sals.nelts = 0;
addr_string = NULL;
- parse_breakpoint_sals (&arg, &sals, &addr_string);
- if (!sals.nelts)
- return;
+ parse_args.arg_p = &arg;
+ parse_args.sals_p = &sals;
+ parse_args.addr_string_p = &addr_string;
+ parse_args.not_found_ptr = ¬_found;
+
+ e = catch_exception (uiout, do_captured_parse_breakpoint,
+ &parse_args, RETURN_MASK_ALL);
+
+ /* If caller is interested in rc value from parse, set value. */
+ switch (e.reason)
+ {
+ case RETURN_QUIT:
+ exception_print (gdb_stderr, e);
+ return e.reason;
+ case RETURN_ERROR:
+ switch (e.error)
+ {
+ case NOT_FOUND_ERROR:
+ /* If called to resolve pending breakpoint, just return
+ error code. */
+ if (pending_bp)
+ return e.reason;
+
+ exception_print (gdb_stderr, e);
+
+ /* If pending breakpoint support is turned off, throw
+ error. */
+
+ if (pending_break_support == AUTO_BOOLEAN_FALSE)
+ deprecated_throw_reason (RETURN_ERROR);
+
+ /* If pending breakpoint support is auto query and the user
+ selects no, then simply return the error code. */
+ if (pending_break_support == AUTO_BOOLEAN_AUTO &&
+ !nquery ("Make breakpoint pending on future shared library load? "))
+ return e.reason;
+
+ /* At this point, either the user was queried about setting
+ a pending breakpoint and selected yes, or pending
+ breakpoint behavior is on and thus a pending breakpoint
+ is defaulted on behalf of the user. */
+ copy_arg = xstrdup (addr_start);
+ addr_string = ©_arg;
+ sals.nelts = 1;
+ sals.sals = &pending_sal;
+ pending_sal.pc = 0;
+ pending = 1;
+ break;
+ default:
+ exception_print (gdb_stderr, e);
+ return e.reason;
+ }
+ default:
+ if (!sals.nelts)
+ return GDB_RC_FAIL;
+ }
/* Create a chain of things that always need to be cleaned up. */
old_chain = make_cleanup (null_cleanup, 0);
- /* Make sure that all storage allocated to SALS gets freed. */
- make_cleanup (xfree, sals.sals);
-
- /* Cleanup the addr_string array but not its contents. */
- make_cleanup (xfree, addr_string);
+ if (!pending)
+ {
+ /* Make sure that all storage allocated to SALS gets freed. */
+ make_cleanup (xfree, sals.sals);
+
+ /* Cleanup the addr_string array but not its contents. */
+ make_cleanup (xfree, addr_string);
+ }
/* Allocate space for all the cond expressions. */
cond = xcalloc (sals.nelts, sizeof (struct expression *));
/* Resolve all line numbers to PC's and verify that the addresses
are ok for the target. */
- breakpoint_sals_to_pc (&sals, addr_start);
+ if (!pending)
+ breakpoint_sals_to_pc (&sals, addr_start);
/* Verify that condition can be parsed, before setting any
breakpoints. Allocate a separate condition expression for each
breakpoint. */
thread = -1; /* No specific thread yet */
- for (i = 0; i < sals.nelts; i++)
+ if (!pending)
{
- char *tok = arg;
- while (tok && *tok)
+ for (i = 0; i < sals.nelts; i++)
{
- char *end_tok;
- int toklen;
- char *cond_start = NULL;
- char *cond_end = NULL;
- while (*tok == ' ' || *tok == '\t')
- tok++;
-
- end_tok = tok;
-
- while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
- end_tok++;
-
- toklen = end_tok - tok;
-
- if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
+ char *tok = arg;
+ while (tok && *tok)
{
- tok = cond_start = end_tok + 1;
- cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
- make_cleanup (xfree, cond[i]);
- cond_end = tok;
- cond_string[i] = savestring (cond_start, cond_end - cond_start);
- make_cleanup (xfree, cond_string[i]);
- }
- else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
- {
- char *tmptok;
-
- tok = end_tok + 1;
- tmptok = tok;
- thread = strtol (tok, &tok, 0);
- if (tok == tmptok)
- error ("Junk after thread keyword.");
- if (!valid_thread_id (thread))
- error ("Unknown thread %d\n", thread);
+ char *end_tok;
+ int toklen;
+ char *cond_start = NULL;
+ char *cond_end = NULL;
+ while (*tok == ' ' || *tok == '\t')
+ tok++;
+
+ end_tok = tok;
+
+ while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
+ end_tok++;
+
+ toklen = end_tok - tok;
+
+ if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
+ {
+ tok = cond_start = end_tok + 1;
+ cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc),
+ 0);
+ make_cleanup (xfree, cond[i]);
+ cond_end = tok;
+ cond_string[i] = savestring (cond_start,
+ cond_end - cond_start);
+ make_cleanup (xfree, cond_string[i]);
+ }
+ else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
+ {
+ char *tmptok;
+
+ tok = end_tok + 1;
+ tmptok = tok;
+ thread = strtol (tok, &tok, 0);
+ if (tok == tmptok)
+ error (_("Junk after thread keyword."));
+ if (!valid_thread_id (thread))
+ error (_("Unknown thread %d."), thread);
+ }
+ else
+ error (_("Junk at end of arguments."));
}
- else
- error ("Junk at end of arguments.");
}
+ create_breakpoints (sals, addr_string, cond, cond_string,
+ hardwareflag ? bp_hardware_breakpoint
+ : bp_breakpoint,
+ tempflag ? disp_del : disp_donttouch,
+ thread, ignore_count, from_tty,
+ pending_bp);
}
-
- create_breakpoints (sals, addr_string, cond, cond_string,
- hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
- tempflag ? disp_del : disp_donttouch,
- thread, ignore_count, from_tty);
-
- if (sals.nelts > 1)
+ else
{
- warning ("Multiple breakpoints were set.");
- warning ("Use the \"delete\" command to delete unwanted breakpoints.");
+ struct symtab_and_line sal;
+ struct breakpoint *b;
+
+ sal.symtab = NULL;
+ sal.pc = 0;
+
+ make_cleanup (xfree, copy_arg);
+
+ b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint
+ : bp_breakpoint);
+ set_breakpoint_count (breakpoint_count + 1);
+ b->number = breakpoint_count;
+ b->cond = *cond;
+ b->thread = thread;
+ b->addr_string = *addr_string;
+ b->cond_string = *cond_string;
+ b->ignore_count = ignore_count;
+ b->pending = 1;
+ b->disposition = tempflag ? disp_del : disp_donttouch;
+ b->from_tty = from_tty;
+ b->flag = flag;
+ mention (b);
}
+
+ if (sals.nelts > 1)
+ warning (_("Multiple breakpoints were set.\n"
+ "Use the \"delete\" command to delete unwanted breakpoints."));
/* That's it. Discard the cleanups for data inserted into the
breakpoint. */
discard_cleanups (breakpoint_chain);
/* But cleanup everything else. */
do_cleanups (old_chain);
+
+ return GDB_RC_OK;
}
/* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
};
static int
-do_captured_breakpoint (void *data)
+do_captured_breakpoint (struct ui_out *uiout, void *data)
{
struct captured_breakpoint_args *args = data;
struct symtabs_and_lines sals;
sals.nelts = 0;
address_end = args->address;
addr_string = NULL;
- parse_breakpoint_sals (&address_end, &sals, &addr_string);
+ parse_breakpoint_sals (&address_end, &sals, &addr_string, 0);
if (!sals.nelts)
return GDB_RC_NONE;
address. That way cleanups can take care of freeing any
memory. */
if (*address_end != '\0')
- error ("Garbage %s following breakpoint address", address_end);
+ error (_("Garbage %s following breakpoint address"), address_end);
/* Resolve all line numbers to PC's. */
breakpoint_sals_to_pc (&sals, args->address);
char *tok = args->condition;
cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
if (*tok != '\0')
- error ("Garbage %s follows condition", tok);
+ error (_("Garbage %s follows condition"), tok);
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 ? disp_del : disp_donttouch,
- args->thread, args->ignore_count, 0/*from-tty*/);
+ args->thread, args->ignore_count, 0/*from-tty*/,
+ NULL/*pending_bp*/);
/* That's it. Discard the cleanups for data inserted into the
breakpoint. */
enum gdb_rc
gdb_breakpoint (char *address, char *condition,
int hardwareflag, int tempflag,
- int thread, int ignore_count)
+ int thread, int ignore_count,
+ char **error_message)
{
struct captured_breakpoint_args args;
args.address = address;
args.tempflag = tempflag;
args.thread = thread;
args.ignore_count = ignore_count;
- return catch_errors (do_captured_breakpoint, &args,
- NULL, RETURN_MASK_ALL);
-}
-
-
-static void
-break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty)
-{
- struct frame_info *frame;
- CORE_ADDR low, high, selected_pc = 0;
- char *extra_args = NULL;
- char *level_arg;
- int extra_args_len = 0, if_arg = 0;
-
- if (!arg ||
- (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
- {
-
- if (default_breakpoint_valid)
- {
- if (deprecated_selected_frame)
- {
- selected_pc = get_frame_pc (deprecated_selected_frame);
- if (arg)
- if_arg = 1;
- }
- else
- error ("No selected frame.");
- }
- else
- error ("No default breakpoint address now.");
- }
- else
- {
- extra_args = strchr (arg, ' ');
- if (extra_args)
- {
- extra_args++;
- extra_args_len = strlen (extra_args);
- level_arg = (char *) xmalloc (extra_args - arg);
- strncpy (level_arg, arg, extra_args - arg - 1);
- level_arg[extra_args - arg - 1] = '\0';
- }
- else
- {
- level_arg = (char *) xmalloc (strlen (arg) + 1);
- strcpy (level_arg, arg);
- }
-
- frame = parse_frame_specification (level_arg);
- if (frame)
- selected_pc = get_frame_pc (frame);
- else
- selected_pc = 0;
- }
- if (if_arg)
- {
- extra_args = arg;
- extra_args_len = strlen (arg);
- }
-
- if (selected_pc)
- {
- if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
- {
- char *addr_string;
- if (extra_args_len)
- addr_string = xstrprintf ("*0x%s %s", paddr_nz (high), extra_args);
- else
- addr_string = xstrprintf ("*0x%s", paddr_nz (high));
- break_command_1 (addr_string, flag, from_tty);
- xfree (addr_string);
- }
- else
- error ("No function contains the specified address");
- }
- else
- error ("Unable to set breakpoint at procedure exit");
-}
-
-
-static void
-break_at_finish_command_1 (char *arg, int flag, int from_tty)
-{
- char *addr_string, *break_string, *beg_addr_string;
- CORE_ADDR low, high;
- struct symtabs_and_lines sals;
- struct symtab_and_line sal;
- struct cleanup *old_chain;
- char *extra_args = NULL;
- int extra_args_len = 0;
- int i, if_arg = 0;
-
- if (!arg ||
- (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
- {
- if (default_breakpoint_valid)
- {
- if (deprecated_selected_frame)
- {
- addr_string = xstrprintf ("*0x%s",
- paddr_nz (get_frame_pc (deprecated_selected_frame)));
- if (arg)
- if_arg = 1;
- }
- else
- error ("No selected frame.");
- }
- else
- error ("No default breakpoint address now.");
- }
- else
- {
- addr_string = (char *) xmalloc (strlen (arg) + 1);
- strcpy (addr_string, arg);
- }
-
- if (if_arg)
- {
- extra_args = arg;
- extra_args_len = strlen (arg);
- }
- else if (arg)
- {
- /* get the stuff after the function name or address */
- extra_args = strchr (arg, ' ');
- if (extra_args)
- {
- extra_args++;
- extra_args_len = strlen (extra_args);
- }
- }
-
- sals.sals = NULL;
- sals.nelts = 0;
-
- beg_addr_string = addr_string;
- sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
- (char ***) NULL, NULL);
-
- xfree (beg_addr_string);
- old_chain = make_cleanup (xfree, sals.sals);
- for (i = 0; (i < sals.nelts); i++)
- {
- sal = sals.sals[i];
- if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
- {
- break_string;
- if (extra_args_len)
- break_string = xstrprintf ("*0x%s %s", paddr_nz (high),
- extra_args);
- else
- break_string = xstrprintf ("*0x%s", paddr_nz (high));
- break_command_1 (break_string, flag, from_tty);
- xfree (break_string);
- }
- else
- error ("No function contains the specified address");
- }
- if (sals.nelts > 1)
- {
- warning ("Multiple breakpoints were set.\n");
- warning ("Use the \"delete\" command to delete unwanted breakpoints.");
- }
- do_cleanups (old_chain);
+ return catch_exceptions_with_msg (uiout, do_captured_breakpoint, &args,
+ error_message, RETURN_MASK_ALL);
}
if (sal->pc == 0 && sal->symtab != NULL)
{
if (!find_line_pc (sal->symtab, sal->line, &pc))
- error ("No line %d in file \"%s\".",
+ error (_("No line %d in file \"%s\"."),
sal->line, sal->symtab->filename);
sal->pc = pc;
}
void
break_command (char *arg, int from_tty)
{
- break_command_1 (arg, 0, from_tty);
-}
-
-void
-break_at_finish_command (char *arg, int from_tty)
-{
- break_at_finish_command_1 (arg, 0, from_tty);
-}
-
-void
-break_at_finish_at_depth_command (char *arg, int from_tty)
-{
- break_at_finish_at_depth_command_1 (arg, 0, from_tty);
+ break_command_1 (arg, 0, from_tty, NULL);
}
void
tbreak_command (char *arg, int from_tty)
{
- break_command_1 (arg, BP_TEMPFLAG, from_tty);
-}
-
-void
-tbreak_at_finish_command (char *arg, int from_tty)
-{
- break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
+ break_command_1 (arg, BP_TEMPFLAG, from_tty, NULL);
}
static void
hbreak_command (char *arg, int from_tty)
{
- break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
+ break_command_1 (arg, BP_HARDWAREFLAG, from_tty, NULL);
}
static void
thbreak_command (char *arg, int from_tty)
{
- break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
+ break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty, NULL);
}
static void
stop_command (char *arg, int from_tty)
{
- printf_filtered ("Specify the type of breakpoint to set.\n\
+ printf_filtered (_("Specify the type of breakpoint to set.\n\
Usage: stop in <function | address>\n\
- stop at <line>\n");
+ stop at <line>\n"));
}
static void
}
if (badInput)
- printf_filtered ("Usage: stop in <function | address>\n");
+ printf_filtered (_("Usage: stop in <function | address>\n"));
else
- break_command_1 (arg, 0, from_tty);
+ break_command_1 (arg, 0, from_tty, NULL);
}
static void
}
if (badInput)
- printf_filtered ("Usage: stop at <line>\n");
+ printf_filtered (_("Usage: stop at <line>\n"));
else
- break_command_1 (arg, 0, from_tty);
+ break_command_1 (arg, 0, from_tty, NULL);
}
/* accessflag: hw_write: watch write,
mark = value_mark ();
val = evaluate_expression (exp);
release_value (val);
- if (VALUE_LAZY (val))
+ if (value_lazy (val))
value_fetch_lazy (val);
tok = arg;
cond_end = tok;
}
if (*tok)
- error ("Junk at end of command.");
+ error (_("Junk at end of command."));
if (accessflag == hw_read)
bp_type = bp_read_watchpoint;
mem_cnt = can_use_hardware_watchpoint (val);
if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
- error ("Expression cannot be implemented with read/access watchpoint.");
+ error (_("Expression cannot be implemented with read/access watchpoint."));
if (mem_cnt != 0)
{
i = hw_watchpoint_used_count (bp_type, &other_type_used);
TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
other_type_used);
if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
- error ("Target does not support this type of hardware watchpoint.");
+ error (_("Target does not support this type of hardware watchpoint."));
if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
- error ("Target can only support one kind of HW watchpoint at a time.");
+ error (_("Target can only support one kind of HW watchpoint at a time."));
}
#if defined(HPUXHPPA)
set watches after getting the program started. */
if (!target_has_execution)
{
- warning ("can't do that without a running program; try \"break main\", \"run\" first");
+ warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
return;
}
#endif /* HPUXHPPA */
scope_breakpoint->loc->requested_address
= get_frame_pc (prev_frame);
scope_breakpoint->loc->address
- = adjust_breakpoint_address (scope_breakpoint->loc->requested_address);
+ = adjust_breakpoint_address (scope_breakpoint->loc->requested_address,
+ scope_breakpoint->type);
/* The scope breakpoint is related to the watchpoint. We
will need to act on them together. */
in hardware. If the watchpoint can not be handled
in hardware return zero. */
-#if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
-#define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
- ((BYTE_SIZE) <= (DEPRECATED_REGISTER_SIZE))
-#endif
-
#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))
function calls are special in any way. So this function may not
notice that an expression involving an inferior function call
can't be watched with hardware watchpoints. FIXME. */
- for (; v; v = v->next)
+ for (; v; v = value_next (v))
{
if (VALUE_LVAL (v) == lval_memory)
{
- if (VALUE_LAZY (v))
+ if (value_lazy (v))
/* A lazy memory lvalue is one that GDB never needed to fetch;
we either just used its address (e.g., `a' in `a.b') or
we never needed it at all (e.g., `a' in `a,b'). */
{
/* Ahh, memory we actually used! Check if we can cover
it with hardware watchpoints. */
- struct type *vtype = check_typedef (VALUE_TYPE (v));
+ struct type *vtype = check_typedef (value_type (v));
/* We only watch structs and arrays if user asked for it
explicitly, never if they just happen to appear in a
|| (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
{
- CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
- int len = TYPE_LENGTH (VALUE_TYPE (v));
+ CORE_ADDR vaddr = VALUE_ADDRESS (v) + value_offset (v);
+ int len = TYPE_LENGTH (value_type (v));
if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
return 0;
}
}
}
- else if (v->lval != not_lval && v->modifiable == 0)
+ else if (VALUE_LVAL (v) != not_lval
+ && deprecated_value_modifiable (v) == 0)
return 0; /* ??? What does this represent? */
- else if (v->lval == lval_register)
+ else if (VALUE_LVAL (v) == lval_register)
return 0; /* cannot watch a register with a HW watchpoint */
}
0, (char ***) NULL, NULL);
if (sals.nelts != 1)
- error ("Couldn't get information on specified line.");
+ error (_("Couldn't get information on specified line."));
sal = sals.sals[0];
xfree (sals.sals); /* malloc'd, so freed */
if (*arg)
- error ("Junk at end of arguments.");
+ error (_("Junk at end of arguments."));
resolve_sal_pc (&sal);
get_frame_id (deprecated_selected_frame),
bp_until);
- if (!event_loop_p || !target_can_async_p ())
+ if (!target_can_async_p ())
old_chain = make_cleanup_delete_breakpoint (breakpoint);
else
old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
where we get a chance to do that is in fetch_inferior_event, so
we must set things up for that. */
- if (event_loop_p && target_can_async_p ())
+ if (target_can_async_p ())
{
/* In this case the arg for the continuation is just the point
in the exec_cleanups chain from where to start doing
sal.pc = get_frame_pc (prev_frame);
breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
bp_until);
- if (!event_loop_p || !target_can_async_p ())
+ if (!target_can_async_p ())
make_cleanup_delete_breakpoint (breakpoint);
else
make_exec_cleanup_delete_breakpoint (breakpoint);
proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
/* Do the cleanups now, anly if we are not running asynchronously,
of if we are, but the target is still synchronous. */
- if (!event_loop_p || !target_can_async_p ())
+ if (!target_can_async_p ())
do_cleanups (old_chain);
}
cond_string = ep_parse_optional_if_clause (&arg);
if ((*arg != '\0') && !isspace (*arg))
- error ("Junk at end of arguments.");
+ error (_("Junk at end of arguments."));
/* If this target supports it, create a fork or vfork catchpoint
and enable reporting of such events. */
create_vfork_event_catchpoint (tempflag, cond_string);
break;
default:
- error ("unsupported or unknown fork kind; cannot catch it");
+ error (_("unsupported or unknown fork kind; cannot catch it"));
break;
}
}
cond_string = ep_parse_optional_if_clause (&arg);
if ((*arg != '\0') && !isspace (*arg))
- error ("Junk at end of arguments.");
+ error (_("Junk at end of arguments."));
/* If this target supports it, create an exec catchpoint
and enable reporting of such events. */
}
if ((*arg != '\0') && !isspace (*arg))
- error ("Junk at end of arguments.");
+ 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)
}
if ((*arg != '\0') && !isspace (*arg))
- error ("Junk at end of arguments.");
+ error (_("Junk at end of arguments."));
/* Create an unload breakpoint that only triggers when an unload of
the specified dll (or any dll, if no pathname was specified)
bptype = bp_catch_catch;
break;
default: /* error condition */
- error ("Internal error -- invalid catchpoint kind");
+ error (_("Internal error -- invalid catchpoint kind"));
}
b = set_raw_breakpoint (*sal, bptype);
annotate_catchpoint (b->number);
if (strstr (b->addr_string, "throw") != NULL)
- printf_filtered ("\nCatchpoint %d (exception thrown)\n",
+ printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
b->number);
else
- printf_filtered ("\nCatchpoint %d (exception caught)\n",
+ printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
b->number);
return PRINT_SRC_AND_LOC;
print_mention_exception_catchpoint (struct breakpoint *b)
{
if (strstr (b->addr_string, "throw") != NULL)
- printf_filtered ("Catchpoint %d (throw)", b->number);
+ printf_filtered (_("Catchpoint %d (throw)"), b->number);
else
- printf_filtered ("Catchpoint %d (catch)", b->number);
+ printf_filtered (_("Catchpoint %d (catch)"), b->number);
}
static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
cond_string = ep_parse_optional_if_clause (&arg);
if ((*arg != '\0') && !isspace (*arg))
- error ("Junk at end of arguments.");
+ error (_("Junk at end of arguments."));
if ((ex_event != EX_EVENT_THROW) &&
(ex_event != EX_EVENT_CATCH))
- error ("Unsupported or unknown exception event; cannot catch it");
+ error (_("Unsupported or unknown exception event; cannot catch it"));
if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
return;
return; /* something went wrong with setting up callbacks */
}
- warning ("Unsupported with this platform/compiler combination.");
+ warning (_("Unsupported with this platform/compiler combination."));
}
/* Cover routine to allow wrapping target_enable_exception_catchpoints
/* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
/* return; */
/* Now, this is not allowed */
- error ("Catch requires an event name.");
+ error (_("Catch requires an event name."));
}
arg1_end = ep_find_event_name_end (arg1_start);
if (arg1_end == NULL)
- error ("catch requires an event");
+ error (_("catch requires an event"));
arg1_length = arg1_end + 1 - arg1_start;
/* Try to match what we found against known event names. */
if (strncmp (arg1_start, "signal", arg1_length) == 0)
{
- error ("Catch of signal not yet implemented");
+ error (_("Catch of signal not yet implemented"));
}
else if (strncmp (arg1_start, "catch", arg1_length) == 0)
{
}
else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
{
- error ("Catch of thread_start not yet implemented");
+ error (_("Catch of thread_start not yet implemented"));
}
else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
{
- error ("Catch of thread_exit not yet implemented");
+ error (_("Catch of thread_exit not yet implemented"));
}
else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
{
- error ("Catch of thread_join not yet implemented");
+ error (_("Catch of thread_join not yet implemented"));
}
else if (strncmp (arg1_start, "start", arg1_length) == 0)
{
- error ("Catch of start not yet implemented");
+ error (_("Catch of start not yet implemented"));
}
else if (strncmp (arg1_start, "exit", arg1_length) == 0)
{
- error ("Catch of exit not yet implemented");
+ error (_("Catch of exit not yet implemented"));
}
else if (strncmp (arg1_start, "fork", arg1_length) == 0)
{
}
else if (strncmp (arg1_start, "stop", arg1_length) == 0)
{
- error ("Catch of stop not yet implemented");
+ error (_("Catch of stop not yet implemented"));
}
/* This doesn't appear to be an event name */
as the name of an exception */
/* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
/* Now this is not allowed */
- error ("Unknown event kind specified for catch");
+ error (_("Unknown event kind specified for catch"));
}
}
sal.symtab = default_breakpoint_symtab;
sal.pc = default_breakpoint_address;
if (sal.symtab == 0)
- error ("No source file specified.");
+ error (_("No source file specified."));
sals.sals[0] = sal;
sals.nelts = 1;
if (found == 0)
{
if (arg)
- error ("No breakpoint at %s.", arg);
+ error (_("No breakpoint at %s."), arg);
else
- error ("No breakpoint at this line.");
+ error (_("No breakpoint at this line."));
}
if (found->next)
from_tty = 1; /* Always report if deleted more than one */
if (from_tty)
- printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
+ {
+ if (!found->next)
+ printf_unfiltered (_("Deleted breakpoint "));
+ else
+ printf_unfiltered (_("Deleted breakpoints "));
+ }
breakpoints_changed ();
while (found)
{
bpstat bs;
struct bp_location *loc;
- if (bpt == NULL)
- error ("Internal error (attempted to delete a NULL breakpoint)");
-
+ gdb_assert (bpt != NULL);
/* Has this bp already been deleted? This can happen because multiple
lists can hold pointers to bp's. bpstat lists are especial culprits.
A real solution to this problem might involve reference counts in bp's,
and/or giving them pointers back to their referencing bpstat's, and
teaching delete_breakpoint to only free a bp's storage when no more
- references were extent. A cheaper bandaid was chosen. */
+ references were extent. A cheaper bandaid was chosen. */
if (bpt->type == bp_none)
return;
- if (delete_breakpoint_hook)
- delete_breakpoint_hook (bpt);
+ if (deprecated_delete_breakpoint_hook)
+ deprecated_delete_breakpoint_hook (bpt);
breakpoint_delete_event (bpt->number);
if (bpt->loc->inserted)
remove_breakpoint (bpt->loc, mark_inserted);
+ free_valchain (bpt->loc);
+
if (breakpoint_chain == bpt)
breakpoint_chain = bpt->next;
isn't actually running. target_enable_exception_callback for a
null target ops vector gives an undesirable error message, so we
check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
- exceptions are supported in this way, it's OK for now. FIXME */
+ exceptions are supported in this way, it's OK for now. FIXME */
if (ep_is_exception_catchpoint (bpt) && target_has_execution)
{
/* Format possible error msg */
&& !b->loc->duplicate
&& b->enable_state != bp_disabled
&& b->enable_state != bp_shlib_disabled
+ && !b->pending
&& b->enable_state != bp_call_disabled)
{
int val;
always be the only one inserted. */
if (b->enable_state == bp_permanent)
internal_error (__FILE__, __LINE__,
- "another breakpoint was inserted on top of "
- "a permanent breakpoint");
+ _("another breakpoint was inserted on top of "
+ "a permanent breakpoint"));
if (b->type == bp_hardware_breakpoint)
val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
{
fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
- print_address_numeric (b->loc->address, 1, tmp_error_stream);
+ deprecated_print_address_numeric (b->loc->address, 1, tmp_error_stream);
fprintf_filtered (tmp_error_stream, ": %s.\n",
safe_strerror (val));
}
/* Ask user only if there are some breakpoints to delete. */
if (!from_tty
- || (breaks_to_delete && query ("Delete all breakpoints? ")))
+ || (breaks_to_delete && query (_("Delete all breakpoints? "))))
{
ALL_BREAKPOINTS_SAFE (b, temp)
{
struct breakpoint *b = (struct breakpoint *) bint;
struct value *mark;
int i;
+ int not_found;
+ int *not_found_ptr = NULL;
struct symtabs_and_lines sals;
char *s;
enum enable_state save_enable;
switch (b->type)
{
case bp_none:
- warning ("attempted to reset apparently deleted breakpoint #%d?",
+ warning (_("attempted to reset apparently deleted breakpoint #%d?"),
b->number);
return 0;
case bp_breakpoint:
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. */
+
+ if (b->pending)
+ break;
+
save_enable = b->enable_state;
if (b->enable_state != bp_shlib_disabled)
b->enable_state = bp_disabled;
+ else
+ /* If resetting a shlib-disabled breakpoint, we don't want to
+ see an error message if it is not found since we will expect
+ this to occur until the shared library is finally reloaded.
+ We accomplish this by giving decode_line_1 a pointer to use
+ for silent notification that the symbol is not found. */
+ not_found_ptr = ¬_found;
set_language (b->language);
input_radix = b->input_radix;
s = b->addr_string;
- sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, NULL);
+ sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL,
+ not_found_ptr);
for (i = 0; i < sals.nelts; i++)
{
resolve_sal_pc (&sals.sals[i]);
b->line_number = sals.sals[i].line;
b->loc->requested_address = sals.sals[i].pc;
b->loc->address
- = adjust_breakpoint_address (b->loc->requested_address);
+ = adjust_breakpoint_address (b->loc->requested_address,
+ b->type);
/* Used to check for duplicates here, but that can
cause trouble, as it doesn't check for disabled
}
b->val = evaluate_expression (b->exp);
release_value (b->val);
- if (VALUE_LAZY (b->val) && breakpoint_enabled (b))
+ if (value_lazy (b->val) && breakpoint_enabled (b))
value_fetch_lazy (b->val);
if (b->cond_string != NULL)
break;
default:
- printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
+ printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
/* fall through */
/* Delete longjmp and overlay event breakpoints; they will be
reset later by breakpoint_re_set. */
if (from_tty)
{
if (count == 0)
- printf_filtered ("Will stop next time breakpoint %d is reached.",
+ printf_filtered (_("Will stop next time breakpoint %d is reached."),
bptnum);
else if (count == 1)
- printf_filtered ("Will ignore next crossing of breakpoint %d.",
+ printf_filtered (_("Will ignore next crossing of breakpoint %d."),
bptnum);
else
- printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
+ printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
count, bptnum);
}
breakpoints_changed ();
return;
}
- error ("No breakpoint number %d.", bptnum);
+ error (_("No breakpoint number %d."), bptnum);
}
/* Clear the ignore counts of all breakpoints. */
int num;
if (p == 0)
- error_no_arg ("a breakpoint number");
+ error_no_arg (_("a breakpoint number"));
num = get_number (&p);
if (num == 0)
- error ("bad breakpoint number: '%s'", args);
+ error (_("bad breakpoint number: '%s'"), args);
if (*p == 0)
- error ("Second argument (specified ignore-count) is missing.");
+ error (_("Second argument (specified ignore-count) is missing."));
set_ignore_count (num,
longest_to_int (value_as_long (parse_and_eval (p))),
int match;
if (p == 0)
- error_no_arg ("one or more breakpoint numbers");
+ error_no_arg (_("one or more breakpoint numbers"));
while (*p)
{
num = get_number_or_range (&p1);
if (num == 0)
{
- warning ("bad breakpoint number at or near '%s'", p);
+ warning (_("bad breakpoint number at or near '%s'"), p);
}
else
{
break;
}
if (match == 0)
- printf_unfiltered ("No breakpoint number %d.\n", num);
+ printf_unfiltered (_("No breakpoint number %d.\n"), num);
}
p = p1;
}
check_duplicates (bpt);
- if (modify_breakpoint_hook)
- modify_breakpoint_hook (bpt);
+ if (deprecated_modify_breakpoint_hook)
+ deprecated_modify_breakpoint_hook (bpt);
breakpoint_modify_event (bpt->number);
}
switch (bpt->type)
{
case bp_none:
- warning ("attempted to disable apparently deleted breakpoint #%d?",
+ warning (_("attempted to disable apparently deleted breakpoint #%d?"),
bpt->number);
continue;
case bp_breakpoint:
static void
do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
{
- struct frame_info *save_selected_frame = NULL;
- int save_selected_frame_level = -1;
int target_resources_ok, other_type_used;
struct value *mark;
TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
i + 1, 0);
if (target_resources_ok == 0)
- error ("No hardware breakpoint support in the target.");
+ error (_("No hardware breakpoint support in the target."));
else if (target_resources_ok < 0)
- error ("Hardware breakpoints used exceeds limit.");
+ error (_("Hardware breakpoints used exceeds limit."));
}
- if (bpt->enable_state != bp_permanent)
- bpt->enable_state = bp_enabled;
- bpt->disposition = disposition;
- check_duplicates (bpt);
- breakpoints_changed ();
-
- if (bpt->type == bp_watchpoint ||
- bpt->type == bp_hardware_watchpoint ||
- bpt->type == bp_read_watchpoint ||
- bpt->type == bp_access_watchpoint)
+ if (bpt->pending)
{
- if (bpt->exp_valid_block != NULL)
+ if (bpt->enable_state != bp_enabled)
{
- struct frame_info *fr =
- fr = frame_find_by_id (bpt->watchpoint_frame);
- if (fr == NULL)
+ /* When enabling a pending breakpoint, we need to check if the breakpoint
+ is resolvable since shared libraries could have been loaded
+ after the breakpoint was disabled. */
+ breakpoints_changed ();
+ if (resolve_pending_breakpoint (bpt) == GDB_RC_OK)
{
- 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_state = bp_disabled;
+ delete_breakpoint (bpt);
return;
}
-
- save_selected_frame = deprecated_selected_frame;
- save_selected_frame_level = frame_relative_level (deprecated_selected_frame);
- select_frame (fr);
+ bpt->enable_state = bp_enabled;
+ bpt->disposition = disposition;
}
-
- value_free (bpt->val);
- mark = value_mark ();
- bpt->val = evaluate_expression (bpt->exp);
- release_value (bpt->val);
- if (VALUE_LAZY (bpt->val))
- value_fetch_lazy (bpt->val);
-
- if (bpt->type == bp_hardware_watchpoint ||
- bpt->type == bp_read_watchpoint ||
+ }
+ else /* Not a pending breakpoint. */
+ {
+ if (bpt->enable_state != bp_permanent)
+ bpt->enable_state = bp_enabled;
+ bpt->disposition = disposition;
+ check_duplicates (bpt);
+ breakpoints_changed ();
+
+ if (bpt->type == bp_watchpoint ||
+ bpt->type == bp_hardware_watchpoint ||
+ bpt->type == bp_read_watchpoint ||
bpt->type == bp_access_watchpoint)
{
- int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
- int mem_cnt = can_use_hardware_watchpoint (bpt->val);
-
- /* Hack around 'unused var' error for some targets here */
- (void) mem_cnt, i;
- target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
- bpt->type, i + mem_cnt, other_type_used);
- /* we can consider of type is bp_hardware_watchpoint, convert to
- bp_watchpoint in the following condition */
- if (target_resources_ok < 0)
+ struct frame_id saved_frame_id;
+
+ saved_frame_id = get_frame_id (get_selected_frame (NULL));
+ if (bpt->exp_valid_block != NULL)
{
- printf_filtered ("\
+ struct frame_info *fr =
+ fr = frame_find_by_id (bpt->watchpoint_frame);
+ if (fr == NULL)
+ {
+ 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_state = bp_disabled;
+ return;
+ }
+ select_frame (fr);
+ }
+
+ value_free (bpt->val);
+ mark = value_mark ();
+ bpt->val = evaluate_expression (bpt->exp);
+ release_value (bpt->val);
+ if (value_lazy (bpt->val))
+ value_fetch_lazy (bpt->val);
+
+ if (bpt->type == bp_hardware_watchpoint ||
+ bpt->type == bp_read_watchpoint ||
+ bpt->type == bp_access_watchpoint)
+ {
+ int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
+ int mem_cnt = can_use_hardware_watchpoint (bpt->val);
+
+ /* Hack around 'unused var' error for some targets here */
+ (void) mem_cnt, i;
+ target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
+ bpt->type, i + mem_cnt, other_type_used);
+ /* we can consider of type is bp_hardware_watchpoint, convert to
+ bp_watchpoint in the following condition */
+ if (target_resources_ok < 0)
+ {
+ printf_filtered (_("\
Cannot enable watchpoint %d because target watch resources\n\
-have been allocated for other watchpoints.\n", bpt->number);
- bpt->enable_state = bp_disabled;
- value_free_to_mark (mark);
- return;
+have been allocated for other watchpoints.\n"), bpt->number);
+ bpt->enable_state = bp_disabled;
+ value_free_to_mark (mark);
+ return;
+ }
}
+
+ select_frame (frame_find_by_id (saved_frame_id));
+ value_free_to_mark (mark);
}
-
- if (save_selected_frame_level >= 0)
- select_frame (save_selected_frame);
- value_free_to_mark (mark);
}
- if (modify_breakpoint_hook)
- modify_breakpoint_hook (bpt);
+
+ if (deprecated_modify_breakpoint_hook)
+ deprecated_modify_breakpoint_hook (bpt);
breakpoint_modify_event (bpt->number);
}
/* The enable command enables the specified breakpoints (or all defined
breakpoints) so they once again become (or continue to be) effective
- in stopping the inferior. */
+ in stopping the inferior. */
static void
enable_command (char *args, int from_tty)
switch (bpt->type)
{
case bp_none:
- warning ("attempted to enable apparently deleted breakpoint #%d?",
+ warning (_("attempted to enable apparently deleted breakpoint #%d?"),
bpt->number);
continue;
case bp_breakpoint:
map_breakpoint_numbers (args, enable_delete_breakpoint);
}
\f
+static void
+set_breakpoint_cmd (char *args, int from_tty)
+{
+}
+
+static void
+show_breakpoint_cmd (char *args, int from_tty)
+{
+}
+
/* Use default_breakpoint_'s, or nothing if they aren't valid. */
struct symtabs_and_lines
{
struct symtabs_and_lines sals;
if (string == 0)
- error ("Empty line specification.");
+ error (_("Empty line specification."));
if (default_breakpoint_valid)
sals = decode_line_1 (&string, funfirstline,
default_breakpoint_symtab,
sals = decode_line_1 (&string, funfirstline,
(struct symtab *) NULL, 0, (char ***) NULL, NULL);
if (*string)
- error ("Junk at end of line specification: %s", string);
+ error (_("Junk at end of line specification: %s"), string);
return sals;
}
\f
void
_initialize_breakpoint (void)
{
+ static struct cmd_list_element *breakpoint_set_cmdlist;
+ static struct cmd_list_element *breakpoint_show_cmdlist;
struct cmd_list_element *c;
+#ifdef SOLIB_ADD
+ observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
+#endif
+
breakpoint_chain = 0;
/* Don't bother to call set_breakpoint_count. $bpnum isn't useful
before a breakpoint is set. */
breakpoint_count = 0;
- add_com ("ignore", class_breakpoint, ignore_command,
- "Set ignore-count of breakpoint number N to COUNT.\n\
-Usage is `ignore N COUNT'.");
+ add_com ("ignore", class_breakpoint, ignore_command, _("\
+Set ignore-count of breakpoint number N to COUNT.\n\
+Usage is `ignore N COUNT'."));
if (xdb_commands)
add_com_alias ("bc", "ignore", class_breakpoint, 1);
- add_com ("commands", class_breakpoint, commands_command,
- "Set commands to be executed when a breakpoint is hit.\n\
+ add_com ("commands", class_breakpoint, commands_command, _("\
+Set commands to be executed when a breakpoint is hit.\n\
Give breakpoint number as argument after \"commands\".\n\
With no argument, the targeted breakpoint is the last one set.\n\
The commands themselves follow starting on the next line.\n\
Type a line containing \"end\" to indicate the end of them.\n\
Give \"silent\" as the first line to make the breakpoint silent;\n\
-then no output is printed when it is hit, except what the commands print.");
+then no output is printed when it is hit, except what the commands print."));
- add_com ("condition", class_breakpoint, condition_command,
- "Specify breakpoint number N to break only if COND is true.\n\
+ add_com ("condition", class_breakpoint, condition_command, _("\
+Specify breakpoint number N to break only if COND is true.\n\
Usage is `condition N COND', where N is an integer and COND is an\n\
-expression to be evaluated whenever breakpoint N is reached.");
+expression to be evaluated whenever breakpoint N is reached."));
- c = 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.");
+by using \"enable delete\" on the breakpoint number."));
set_cmd_completer (c, location_completer);
- c = 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.");
+some target hardware may not have this support."));
set_cmd_completer (c, location_completer);
- c = 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.");
+so it will be deleted when hit."));
set_cmd_completer (c, location_completer);
- add_prefix_cmd ("enable", class_breakpoint, enable_command,
- "Enable some breakpoints.\n\
+ add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
+Enable some breakpoints.\n\
Give breakpoint numbers (separated by spaces) as arguments.\n\
With no subcommand, breakpoints are enabled until you command otherwise.\n\
This is used to cancel the effect of the \"disable\" command.\n\
-With a subcommand you can enable temporarily.",
+With a subcommand you can enable temporarily."),
&enablelist, "enable ", 1, &cmdlist);
if (xdb_commands)
- add_com ("ab", class_breakpoint, enable_command,
- "Enable some breakpoints.\n\
+ add_com ("ab", class_breakpoint, enable_command, _("\
+Enable some breakpoints.\n\
Give breakpoint numbers (separated by spaces) as arguments.\n\
With no subcommand, breakpoints are enabled until you command otherwise.\n\
This is used to cancel the effect of the \"disable\" command.\n\
-With a subcommand you can enable temporarily.");
+With a subcommand you can enable temporarily."));
add_com_alias ("en", "enable", class_breakpoint, 1);
- add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
- "Enable some breakpoints.\n\
+ add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
+Enable some breakpoints.\n\
Give breakpoint numbers (separated by spaces) as arguments.\n\
This is used to cancel the effect of the \"disable\" command.\n\
-May be abbreviated to simply \"enable\".\n",
+May be abbreviated to simply \"enable\".\n"),
&enablebreaklist, "enable breakpoints ", 1, &enablelist);
- add_cmd ("once", no_class, enable_once_command,
- "Enable breakpoints for one hit. Give breakpoint numbers.\n\
-If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
+ add_cmd ("once", no_class, enable_once_command, _("\
+Enable breakpoints for one hit. Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
&enablebreaklist);
- add_cmd ("delete", no_class, enable_delete_command,
- "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
-If a breakpoint is hit while enabled in this fashion, it is deleted.",
+ add_cmd ("delete", no_class, enable_delete_command, _("\
+Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it is deleted."),
&enablebreaklist);
- add_cmd ("delete", no_class, enable_delete_command,
- "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
-If a breakpoint is hit while enabled in this fashion, it is deleted.",
+ add_cmd ("delete", no_class, enable_delete_command, _("\
+Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it is deleted."),
&enablelist);
- add_cmd ("once", no_class, enable_once_command,
- "Enable breakpoints for one hit. Give breakpoint numbers.\n\
-If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
+ add_cmd ("once", no_class, enable_once_command, _("\
+Enable breakpoints for one hit. Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
&enablelist);
- add_prefix_cmd ("disable", class_breakpoint, disable_command,
- "Disable some breakpoints.\n\
+ add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
+Disable some breakpoints.\n\
Arguments are breakpoint numbers with spaces in between.\n\
To disable all breakpoints, give no argument.\n\
-A disabled breakpoint is not forgotten, but has no effect until reenabled.",
+A disabled breakpoint is not forgotten, but has no effect until reenabled."),
&disablelist, "disable ", 1, &cmdlist);
add_com_alias ("dis", "disable", class_breakpoint, 1);
add_com_alias ("disa", "disable", class_breakpoint, 1);
if (xdb_commands)
- add_com ("sb", class_breakpoint, disable_command,
- "Disable some breakpoints.\n\
+ add_com ("sb", class_breakpoint, disable_command, _("\
+Disable some breakpoints.\n\
Arguments are breakpoint numbers with spaces in between.\n\
To disable all breakpoints, give no argument.\n\
-A disabled breakpoint is not forgotten, but has no effect until reenabled.");
+A disabled breakpoint is not forgotten, but has no effect until reenabled."));
- add_cmd ("breakpoints", class_alias, disable_command,
- "Disable some breakpoints.\n\
+ add_cmd ("breakpoints", class_alias, disable_command, _("\
+Disable some breakpoints.\n\
Arguments are breakpoint numbers with spaces in between.\n\
To disable all breakpoints, give no argument.\n\
A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
-This command may be abbreviated \"disable\".",
+This command may be abbreviated \"disable\"."),
&disablelist);
- add_prefix_cmd ("delete", class_breakpoint, delete_command,
- "Delete some breakpoints or auto-display expressions.\n\
+ add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
+Delete some breakpoints or auto-display expressions.\n\
Arguments are breakpoint numbers with spaces in between.\n\
To delete all breakpoints, give no argument.\n\
\n\
Also a prefix command for deletion of other GDB objects.\n\
-The \"unset\" command is also an alias for \"delete\".",
+The \"unset\" command is also an alias for \"delete\"."),
&deletelist, "delete ", 1, &cmdlist);
add_com_alias ("d", "delete", class_breakpoint, 1);
if (xdb_commands)
- add_com ("db", class_breakpoint, delete_command,
- "Delete some breakpoints.\n\
+ add_com ("db", class_breakpoint, delete_command, _("\
+Delete some breakpoints.\n\
Arguments are breakpoint numbers with spaces in between.\n\
-To delete all breakpoints, give no argument.\n");
+To delete all breakpoints, give no argument.\n"));
- add_cmd ("breakpoints", class_alias, delete_command,
- "Delete some breakpoints or auto-display expressions.\n\
+ add_cmd ("breakpoints", class_alias, delete_command, _("\
+Delete some breakpoints or auto-display expressions.\n\
Arguments are breakpoint numbers with spaces in between.\n\
To delete all breakpoints, give no argument.\n\
-This command may be abbreviated \"delete\".",
+This command may be abbreviated \"delete\"."),
&deletelist);
- add_com ("clear", class_breakpoint, clear_command,
- concat ("Clear breakpoint at specified line or function.\n\
+ add_com ("clear", class_breakpoint, clear_command, _("\
+Clear breakpoint at specified line or function.\n\
Argument may be line number, function name, or \"*\" and an address.\n\
If line number is specified, all breakpoints in that line are cleared.\n\
If function is specified, breakpoints at beginning of function are cleared.\n\
-If an address is specified, breakpoints at that address are cleared.\n\n",
- "With no argument, clears all breakpoints in the line that the selected frame\n\
+If an address is specified, breakpoints at that address are cleared.\n\
+\n\
+With no argument, clears all breakpoints in the line that the selected frame\n\
is executing in.\n\
\n\
-See also the \"delete\" command which clears breakpoints by number.", NULL));
+See also the \"delete\" command which clears breakpoints by number."));
- c = add_com ("break", class_breakpoint, break_command,
- concat ("Set breakpoint at specified line or function.\n\
+ c = add_com ("break", class_breakpoint, break_command, _("\
+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\
-If an address is specified, break at that exact address.\n",
- "With no arg, uses current execution address of selected stack frame.\n\
+If an address is specified, break at that exact address.\n\
+With no arg, uses current execution address of selected stack frame.\n\
This is useful for breaking on return to a stack frame.\n\
\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));
+Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
set_cmd_completer (c, location_completer);
add_com_alias ("b", "break", class_run, 1);
if (dbx_commands)
{
- add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
- "Break in function/address or break at a line in the current file.",
+ add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
+Break in function/address or break at a line in the current file."),
&stoplist, "stop ", 1, &cmdlist);
add_cmd ("in", class_breakpoint, stopin_command,
- "Break in function or address.\n", &stoplist);
+ _("Break in function or address."), &stoplist);
add_cmd ("at", class_breakpoint, stopat_command,
- "Break at a line in the current file.\n", &stoplist);
- add_com ("status", class_info, breakpoints_info,
- concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
+ _("Break at a line in the current file."), &stoplist);
+ add_com ("status", class_info, breakpoints_info, _("\
+Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
The \"Type\" column indicates one of:\n\
\tbreakpoint - normal breakpoint\n\
\twatchpoint - watchpoint\n\
The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\n",
- "Convenience variable \"$_\" and default examine address for \"x\"\n\
+address and file/line number respectively.\n\
+\n\
+Convenience variable \"$_\" and default examine address for \"x\"\n\
are set to the address of the last breakpoint listed.\n\n\
Convenience variable \"$bpnum\" contains the number of the last\n\
-breakpoint set.", NULL));
+breakpoint set."));
}
- add_info ("breakpoints", breakpoints_info,
- concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
+ add_info ("breakpoints", breakpoints_info, _("\
+Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
The \"Type\" column indicates one of:\n\
\tbreakpoint - normal breakpoint\n\
\twatchpoint - watchpoint\n\
The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\n",
- "Convenience variable \"$_\" and default examine address for \"x\"\n\
+address and file/line number respectively.\n\
+\n\
+Convenience variable \"$_\" and default examine address for \"x\"\n\
are set to the address of the last breakpoint listed.\n\n\
Convenience variable \"$bpnum\" contains the number of the last\n\
-breakpoint set.", NULL));
+breakpoint set."));
if (xdb_commands)
- add_com ("lb", class_breakpoint, breakpoints_info,
- concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
+ add_com ("lb", class_breakpoint, breakpoints_info, _("\
+Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
The \"Type\" column indicates one of:\n\
\tbreakpoint - normal breakpoint\n\
\twatchpoint - watchpoint\n\
The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\n",
- "Convenience variable \"$_\" and default examine address for \"x\"\n\
+address and file/line number respectively.\n\
+\n\
+Convenience variable \"$_\" and default examine address for \"x\"\n\
are set to the address of the last breakpoint listed.\n\n\
Convenience variable \"$bpnum\" contains the number of the last\n\
-breakpoint set.", NULL));
+breakpoint set."));
- add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
- concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
+ add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
+Status of all breakpoints, or breakpoint number NUMBER.\n\
The \"Type\" column indicates one of:\n\
\tbreakpoint - normal breakpoint\n\
\twatchpoint - watchpoint\n\
\tlongjmp - internal breakpoint used to step through longjmp()\n\
\tlongjmp resume - internal breakpoint at the target of longjmp()\n\
\tuntil - internal breakpoint used by the \"until\" command\n\
-\tfinish - internal breakpoint used by the \"finish\" command\n",
- "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
+\tfinish - internal breakpoint used by the \"finish\" command\n\
+The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\n",
- "Convenience variable \"$_\" and default examine address for \"x\"\n\
-are set to the address of the last breakpoint listed.\n\n\
+address and file/line number respectively.\n\
+\n\
+Convenience variable \"$_\" and default examine address for \"x\"\n\
+are set to the address of the last breakpoint listed.\n\
+\n\
Convenience variable \"$bpnum\" contains the number of the last\n\
-breakpoint set.", NULL),
+breakpoint set."),
&maintenanceinfolist);
- add_com ("catch", class_breakpoint, catch_command,
- "Set catchpoints to catch events.\n\
+ add_com ("catch", class_breakpoint, catch_command, _("\
+Set catchpoints to catch events.\n\
Raised signals may be caught:\n\
\tcatch signal - all signals\n\
\tcatch signal <signame> - a particular signal\n\
\n\
Do \"help set follow-fork-mode\" for info on debugging your program\n\
after a fork or vfork is caught.\n\n\
-Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
+Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
- add_com ("tcatch", class_breakpoint, tcatch_command,
- "Set temporary catchpoints to catch events.\n\
+ add_com ("tcatch", class_breakpoint, tcatch_command, _("\
+Set temporary catchpoints to catch events.\n\
Args like \"catch\" command.\n\
Like \"catch\" except the catchpoint is only temporary,\n\
so it will be deleted when hit. Equivalent to \"catch\" followed\n\
-by using \"enable delete\" on the catchpoint number.");
+by using \"enable delete\" on the catchpoint number."));
- c = 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.");
+an expression changes."));
set_cmd_completer (c, location_completer);
- c = 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.");
+an expression is read."));
set_cmd_completer (c, location_completer);
- c = 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.");
+an expression is either read or written."));
set_cmd_completer (c, location_completer);
add_info ("watchpoints", breakpoints_info,
- "Synonym for ``info breakpoints''.");
+ _("Synonym for ``info breakpoints''."));
- c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
- (char *) &can_use_hw_watchpoints,
- "Set debugger's willingness to use watchpoint hardware.\n\
+ /* XXX: cagney/2005-02-23: This should be a boolean, and should
+ respond to changes - contrary to the description. */
+ add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
+ &can_use_hw_watchpoints, _("\
+Set debugger's willingness to use watchpoint hardware."), _("\
+Show debugger's willingness to use watchpoint hardware."), _("\
If zero, gdb will not use hardware for new watchpoints, even if\n\
such is available. (However, any hardware watchpoints that were\n\
created before setting this to nonzero, will continue to use watchpoint\n\
-hardware.)",
- &setlist);
- add_show_from_set (c, &showlist);
+hardware.)"),
+ NULL,
+ show_can_use_hw_watchpoints,
+ &setlist, &showlist);
can_use_hw_watchpoints = 1;
+
+ add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
+Breakpoint specific settings\n\
+Configure various breakpoint-specific variables such as\n\
+pending breakpoint behavior"),
+ &breakpoint_set_cmdlist, "set breakpoint ",
+ 0/*allow-unknown*/, &setlist);
+ add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
+Breakpoint specific settings\n\
+Configure various breakpoint-specific variables such as\n\
+pending breakpoint behavior"),
+ &breakpoint_show_cmdlist, "show breakpoint ",
+ 0/*allow-unknown*/, &showlist);
+
+ add_setshow_auto_boolean_cmd ("pending", no_class,
+ &pending_break_support, _("\
+Set debugger's behavior regarding pending breakpoints."), _("\
+Show debugger's behavior regarding pending breakpoints."), _("\
+If on, an unrecognized breakpoint location will cause gdb to create a\n\
+pending breakpoint. If off, an unrecognized breakpoint location results in\n\
+an error. If auto, an unrecognized breakpoint location results in a\n\
+user-query to see if a pending breakpoint should be created."),
+ NULL,
+ show_pending_break_support,
+ &breakpoint_set_cmdlist,
+ &breakpoint_show_cmdlist);
+
+ pending_break_support = AUTO_BOOLEAN_AUTO;
}