#include "annotate.h"
#include "symfile.h"
#include "objfiles.h"
+#include "source.h"
#include "linespec.h"
#include "completer.h"
#include "gdb.h"
#include "ui-out.h"
+#include "cli/cli-script.h"
+#include "gdb_assert.h"
#include "gdb-events.h"
int return_val = 0; /* return success code. */
int val = 0;
int disabled_breaks = 0;
+ int hw_breakpoint_error = 0;
+#ifdef ONE_PROCESS_WRITETEXT
+ int process_warning = 0;
+#endif
static char message1[] = "Error inserting catchpoint %d:\n";
static char message[sizeof (message1) + 30];
+ struct ui_file *tmp_error_stream = mem_fileopen ();
+ make_cleanup_ui_file_delete (tmp_error_stream);
+
+ /* Explicitly mark the warning -- this will only be printed if
+ there was an error. */
+ fprintf_unfiltered (tmp_error_stream, "Warning:\n");
ALL_BREAKPOINTS_SAFE (b, temp)
{
if (b->enable_state == bp_permanent)
/* Permanent breakpoints cannot be inserted or removed. */
continue;
- else if (b->type != bp_watchpoint
+ if ((b->type == bp_watchpoint
+ || b->type == bp_hardware_watchpoint
+ || b->type == bp_read_watchpoint
+ || b->type == bp_access_watchpoint) && (!b->val))
+ {
+ struct value *val;
+ val = evaluate_expression (b->exp);
+ release_value (val);
+ if (VALUE_LAZY (val))
+ value_fetch_lazy (val);
+ b->val = val;
+ }
+ if (b->type != bp_watchpoint
&& b->type != bp_hardware_watchpoint
&& b->type != bp_read_watchpoint
&& b->type != bp_access_watchpoint
/* Set a software (trap) breakpoint at the LMA. */
val = target_insert_breakpoint (addr, b->shadow_contents);
if (val != 0)
- warning ("overlay breakpoint %d failed: in ROM?",
- b->number);
+ fprintf_unfiltered (tmp_error_stream,
+ "Overlay breakpoint %d failed: in ROM?",
+ b->number);
}
}
/* Shall we set a breakpoint at the VMA? */
b->enable_state = bp_shlib_disabled;
if (!disabled_breaks)
{
- target_terminal_ours_for_output ();
- warning ("Cannot insert breakpoint %d:", b->number);
- warning ("Temporarily disabling shared library breakpoints:");
+ fprintf_unfiltered (tmp_error_stream,
+ "Cannot insert breakpoint %d.\n",
+ b->number);
+ fprintf_unfiltered (tmp_error_stream,
+ "Temporarily disabling shared library breakpoints:\n");
}
disabled_breaks = 1;
- warning ("breakpoint #%d ", b->number);
+ fprintf_unfiltered (tmp_error_stream,
+ "breakpoint #%d\n", b->number);
}
else
#endif
{
- target_terminal_ours_for_output ();
- warning ("Cannot insert breakpoint %d:", b->number);
#ifdef ONE_PROCESS_WRITETEXT
- warning ("The same program may be running in another process.");
+ process_warning = 1;
#endif
- memory_error (val, b->address); /* which bombs us out */
+ if (b->type == bp_hardware_breakpoint)
+ {
+ hw_breakpoint_error = 1;
+ fprintf_unfiltered (tmp_error_stream,
+ "Cannot insert hardware breakpoint %d.\n",
+ b->number);
+ }
+ else
+ {
+ 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->address, 1, tmp_error_stream);
+ fprintf_filtered (tmp_error_stream, ": %s.\n",
+ safe_strerror (val));
+ }
+
}
}
else
if (val)
{
/* Couldn't set breakpoint for some reason */
- target_terminal_ours_for_output ();
- warning ("Cannot insert catchpoint %d; disabling it.",
- b->number);
+ fprintf_unfiltered (tmp_error_stream,
+ "Cannot insert catchpoint %d; disabling it.\n",
+ b->number);
+ fprintf_filtered (tmp_error_stream,
+ "Error accessing memory address ");
+ print_address_numeric (b->address, 1, tmp_error_stream);
+ fprintf_filtered (tmp_error_stream, ": %s.\n",
+ safe_strerror (val));
b->enable_state = bp_disabled;
}
else
if (val == -1)
{
/* something went wrong */
- target_terminal_ours_for_output ();
- warning ("Cannot insert catchpoint %d; disabling it.",
- b->number);
+ fprintf_unfiltered (tmp_error_stream,
+ "Cannot insert catchpoint %d; disabling it.\n",
+ b->number);
b->enable_state = bp_disabled;
}
}
/* Save the current frame and level so we can restore it after
evaluating the watchpoint expression on its own frame. */
- saved_frame = selected_frame;
- saved_level = frame_relative_level (selected_frame);
+ saved_frame = deprecated_selected_frame;
+ saved_level = frame_relative_level (deprecated_selected_frame);
/* Determine if the watchpoint is within scope. */
if (b->exp_valid_block == NULL)
addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
len = TYPE_LENGTH (VALUE_TYPE (v));
- type = hw_write;
+ type = hw_write;
if (b->type == bp_read_watchpoint)
type = hw_read;
else if (b->type == bp_access_watchpoint)
if (!b->inserted)
{
remove_breakpoint (b, mark_uninserted);
- warning ("Could not insert hardware watchpoint %d.",
- b->number);
+ hw_breakpoint_error = 1;
+ fprintf_unfiltered (tmp_error_stream,
+ "Could not insert hardware watchpoint %d.\n",
+ b->number);
val = -1;
}
}
}
/* Restore the frame and level. */
- if ((saved_frame != selected_frame) ||
- (saved_level != frame_relative_level (selected_frame)))
+ if ((saved_frame != deprecated_selected_frame) ||
+ (saved_level != frame_relative_level (deprecated_selected_frame)))
select_frame (saved_frame);
if (val)
}
if (val < 0)
{
- target_terminal_ours_for_output ();
- warning ("Cannot insert catchpoint %d.", b->number);
+ fprintf_unfiltered (tmp_error_stream,
+ "Cannot insert catchpoint %d.", b->number);
}
else
b->inserted = 1;
return_val = val; /* remember failure */
}
}
-
+
+ if (return_val)
+ {
+ /* If a hardware breakpoint or watchpoint was inserted, add a
+ message about possibly exhausted resources. */
+ if (hw_breakpoint_error)
+ {
+ fprintf_unfiltered (tmp_error_stream,
+ "Could not insert hardware breakpoints:\n\
+You may have requested too many hardware breakpoints/watchpoints.\n");
+ }
+#ifdef ONE_PROCESS_WRITETEXT
+ if (process_warning)
+ fprintf_unfiltered (tmp_error_stream,
+ "The same program may be running in another process.");
+#endif
+ target_terminal_ours_for_output ();
+ error_stream (tmp_error_stream);
+ }
return return_val;
}
-
int
remove_breakpoints (void)
{
/* Likewise for watchpoints on local expressions. */
if (b->exp_valid_block != NULL)
delete_breakpoint (b);
+ if (context == inf_starting)
+ {
+ /* Reset val field to force reread of starting value
+ in insert_breakpoints. */
+ if (b->val)
+ value_free (b->val);
+ b->val = NULL;
+ }
break;
default:
/* Likewise for exception catchpoints in dynamic-linked
}
/* Return nonzero if FRAME is a dummy frame. We can't use
- PC_IN_CALL_DUMMY because figuring out the saved SP would take too
- much time, at least using get_saved_register on the 68k. This
- means that for this function to work right a port must use the
+ DEPRECATED_PC_IN_CALL_DUMMY because figuring out the saved SP would
+ take too much time, at least using get_saved_register on the 68k.
+ This means that for this function to work right a port must use the
bp_call_dummy breakpoint. */
int
-frame_in_dummy (struct frame_info *frame)
+deprecated_frame_in_dummy (struct frame_info *frame)
{
struct breakpoint *b;
if (!CALL_DUMMY_P)
return 0;
- if (USE_GENERIC_DUMMY_FRAMES)
- return generic_pc_in_call_dummy (frame->pc, frame->frame, frame->frame);
+ /* 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
- && b->frame == frame->frame
+ && 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. */
- && (frame->pc
+ && (get_frame_pc (frame)
>= (b->address
- - SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
- && frame->pc <= b->address)
+ - SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
+ && get_frame_pc (frame) <= b->address)
return 1;
}
return 0;
q = p->next;
if (p->old_val != NULL)
value_free (p->old_val);
+ free_command_lines (&p->commands);
xfree (p);
p = q;
}
{
for (; bs != NULL; bs = bs->next)
{
- bs->commands = NULL;
+ free_command_lines (&bs->commands);
if (bs->old_val != NULL)
{
value_free (bs->old_val);
to look at, so start over. */
goto top;
else
- bs->commands = NULL;
+ free_command_lines (&bs->commands);
}
-
- executing_breakpoint_commands = 0;
- discard_cleanups (old_chain);
+ do_cleanups (old_chain);
}
/* This is the normal print function for a bpstat. In the future,
trace/singlestep trap event, we would not want to subtract
DECR_PC_AFTER_BREAK from the PC. */
- bp_addr = *pc - (not_a_sw_breakpoint && !SOFTWARE_SINGLE_STEP_P () ?
- 0 : DECR_PC_AFTER_BREAK);
+ bp_addr = *pc - (not_a_sw_breakpoint ? 0 : DECR_PC_AFTER_BREAK);
ALL_BREAKPOINTS_SAFE (b, temp)
{
continue;
if ((b->type == bp_catch_fork)
- && !target_has_forked (PIDGET (inferior_ptid),
- &b->forked_inferior_pid))
+ && !inferior_has_forked (PIDGET (inferior_ptid),
+ &b->forked_inferior_pid))
continue;
if ((b->type == bp_catch_vfork)
- && !target_has_vforked (PIDGET (inferior_ptid),
- &b->forked_inferior_pid))
+ && !inferior_has_vforked (PIDGET (inferior_ptid),
+ &b->forked_inferior_pid))
continue;
if ((b->type == bp_catch_exec)
- && !target_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
+ && !inferior_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
continue;
if (ep_is_exception_catchpoint (b) &&
real_breakpoint = 1;
}
- if (b->frame &&
- b->frame != (get_current_frame ())->frame)
+ if (frame_id_p (b->frame_id)
+ && !frame_id_eq (b->frame_id, get_frame_id (get_current_frame ())))
bs->stop = 0;
else
{
/* We will stop here */
if (b->disposition == disp_disable)
b->enable_state = bp_disabled;
- bs->commands = b->commands;
+ bs->commands = copy_command_lines (b->commands);
if (b->silent)
bs->print = 0;
if (bs->commands &&
ui_out_text (uiout, "\n");
- if (b->frame)
+ if (frame_id_p (b->frame_id))
{
annotate_field (6);
ui_out_text (uiout, "\tstop only in stack frame at ");
- ui_out_field_core_addr (uiout, "frame", b->frame);
+ /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
+ the frame ID. */
+ ui_out_field_core_addr (uiout, "frame", b->frame_id.base);
ui_out_text (uiout, "\n");
}
b->silent = 0;
b->ignore_count = 0;
b->commands = NULL;
- b->frame = 0;
+ b->frame_id = null_frame_id;
b->dll_pathname = NULL;
b->triggered_dll_pathname = NULL;
b->forked_inferior_pid = 0;
struct symtab_and_line sal;
struct breakpoint *b;
- INIT_SAL (&sal); /* initialize to zeroes */
+ init_sal (&sal); /* initialize to zeroes */
sal.pc = address;
sal.section = find_pc_overlay (sal.pc);
create_thread_event_breakpoint (CORE_ADDR address)
{
struct breakpoint *b;
- char addr_string[80]; /* Surely an addr can't be longer than that. */
b = create_internal_breakpoint (address, bp_thread_event);
b->enable_state = bp_enabled;
/* addr_string has to be used or breakpoint_re_set will delete me. */
- sprintf (addr_string, "*0x%s", paddr (b->address));
- b->addr_string = xstrdup (addr_string);
+ xasprintf (&b->addr_string, "*0x%s", paddr (b->address));
return b;
}
struct breakpoint *b;
int thread = -1; /* All threads. */
- INIT_SAL (&sal);
+ init_sal (&sal);
sal.pc = 0;
sal.symtab = NULL;
sal.line = 0;
struct breakpoint *b;
int thread = -1; /* All threads. */
- INIT_SAL (&sal);
+ init_sal (&sal);
sal.pc = 0;
sal.symtab = NULL;
sal.line = 0;
that gets deleted automatically... */
void
-set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_info *frame)
+set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id)
{
register struct breakpoint *b;
{
b->address = pc;
b->enable_state = bp_enabled;
- if (frame != NULL)
- b->frame = frame->frame;
- else
- b->frame = 0;
+ b->frame_id = frame_id;
check_duplicates (b);
return;
}
Restrict it to frame FRAME if FRAME is nonzero. */
struct breakpoint *
-set_momentary_breakpoint (struct symtab_and_line sal, struct frame_info *frame,
+set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
enum bptype type)
{
register struct breakpoint *b;
b = set_raw_breakpoint (sal, type);
b->enable_state = bp_enabled;
b->disposition = disp_donttouch;
- b->frame = (frame ? frame->frame : 0);
+ b->frame_id = frame_id;
/* If we're debugging a multi-threaded program, then we
want momentary breakpoints to be active in only a
b->number = breakpoint_count;
b->cond = cond[i];
b->thread = thread;
- b->addr_string = addr_string[i];
+ if (addr_string[i])
+ b->addr_string = addr_string[i];
+ else
+ /* addr_string has to be used or breakpoint_re_set will delete
+ me. */
+ xasprintf (&b->addr_string, "*0x%s", paddr (b->address));
b->cond_string = cond_string[i];
b->ignore_count = ignore_count;
b->enable_state = bp_enabled;
if (default_breakpoint_valid)
{
struct symtab_and_line sal;
- INIT_SAL (&sal); /* initialize to zeroes */
+ init_sal (&sal); /* initialize to zeroes */
sals->sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
sal.pc = default_breakpoint_address;
/* Force almost all breakpoints to be in terms of the
current_source_symtab (which is decode_line_1's default). This
should produce the results we want almost all of the time while
- leaving default_breakpoint_* alone. */
+ leaving default_breakpoint_* alone.
+ ObjC: However, don't match an Objective-C method name which
+ may have a '+' or '-' succeeded by a '[' */
+
+ struct symtab_and_line cursal = get_current_source_symtab_and_line ();
+
if (default_breakpoint_valid
- && (!current_source_symtab
- || (strchr ("+-", (*address)[0]) != NULL)))
+ && (!cursal.symtab
+ || ((strchr ("+-", (*address)[0]) != NULL)
+ && ((*address)[1] != '['))))
*sals = decode_line_1 (address, 1, default_breakpoint_symtab,
default_breakpoint_line, addr_string);
else
if (default_breakpoint_valid)
{
- if (selected_frame)
+ if (deprecated_selected_frame)
{
- selected_pc = selected_frame->pc;
+ selected_pc = get_frame_pc (deprecated_selected_frame);
if (arg)
if_arg = 1;
}
frame = parse_frame_specification (level_arg);
if (frame)
- selected_pc = frame->pc;
+ selected_pc = get_frame_pc (frame);
else
selected_pc = 0;
}
{
if (default_breakpoint_valid)
{
- if (selected_frame)
+ if (deprecated_selected_frame)
{
addr_string = (char *) xmalloc (15);
- sprintf (addr_string, "*0x%s", paddr_nz (selected_frame->pc));
+ sprintf (addr_string, "*0x%s",
+ paddr_nz (get_frame_pc (deprecated_selected_frame)));
if (arg)
if_arg = 1;
}
enum bptype bp_type;
int mem_cnt = 0;
- INIT_SAL (&sal); /* initialize to zeroes */
+ init_sal (&sal); /* initialize to zeroes */
/* Parse arguments. */
innermost_block = NULL;
if (frame)
{
prev_frame = get_prev_frame (frame);
- get_frame_id (frame, &b->watchpoint_frame);
+ b->watchpoint_frame = get_frame_id (frame);
}
else
{
if (prev_frame)
{
struct breakpoint *scope_breakpoint;
- struct symtab_and_line scope_sal;
-
- INIT_SAL (&scope_sal); /* initialize to zeroes */
- scope_sal.pc = get_frame_pc (prev_frame);
- scope_sal.section = find_pc_overlay (scope_sal.pc);
-
- scope_breakpoint = set_raw_breakpoint (scope_sal,
- bp_watchpoint_scope);
- set_breakpoint_count (breakpoint_count + 1);
- scope_breakpoint->number = breakpoint_count;
+ scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
+ bp_watchpoint_scope);
scope_breakpoint->enable_state = bp_enabled;
scope_breakpoint->disposition = disp_del;
/* Only break in the proper frame (help with recursion). */
- scope_breakpoint->frame = prev_frame->frame;
+ scope_breakpoint->frame_id = get_frame_id (prev_frame);
/* Set the address at which we will stop. */
scope_breakpoint->address = get_frame_pc (prev_frame);
{
struct symtabs_and_lines sals;
struct symtab_and_line sal;
- struct frame_info *prev_frame = get_prev_frame (selected_frame);
+ struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);
struct breakpoint *breakpoint;
struct cleanup *old_chain;
struct continuation_arg *arg1;
resolve_sal_pc (&sal);
- breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
+ breakpoint =
+ set_momentary_breakpoint (sal,get_frame_id (deprecated_selected_frame),
+ bp_until);
if (!event_loop_p || !target_can_async_p ())
old_chain = make_cleanup_delete_breakpoint (breakpoint);
{
sal = find_pc_line (prev_frame->pc, 0);
sal.pc = prev_frame->pc;
- breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
+ breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
+ bp_until);
if (!event_loop_p || !target_can_async_p ())
make_cleanup_delete_breakpoint (breakpoint);
else
/* Not sure whether an error message is always the correct response,
but it's better than a core dump. */
- if (selected_frame == NULL)
+ if (deprecated_selected_frame == NULL)
error ("No selected frame.");
- block = get_frame_block (selected_frame, 0);
- pc = selected_frame->pc;
+ block = get_frame_block (deprecated_selected_frame, 0);
+ pc = get_frame_pc (deprecated_selected_frame);
sals.nelts = 0;
sals.sals = NULL;
char *save_arg;
int i;
- INIT_SAL (&sal); /* initialize to zeroes */
+ init_sal (&sal); /* initialize to zeroes */
/* If no arg given, or if first arg is 'if ', all active catch clauses
are breakpointed. */
sals.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
make_cleanup (xfree, sals.sals);
- INIT_SAL (&sal); /* initialize to zeroes */
+ init_sal (&sal); /* initialize to zeroes */
sal.line = default_breakpoint_line;
sal.symtab = default_breakpoint_symtab;
sal.pc = default_breakpoint_address;
else
val = target_insert_breakpoint (b->address, b->shadow_contents);
+ /* If there was an error in the insert, print a message, then stop execution. */
if (val != 0)
{
+ struct ui_file *tmp_error_stream = mem_fileopen ();
+ make_cleanup_ui_file_delete (tmp_error_stream);
+
+
+ if (b->type == bp_hardware_breakpoint)
+ {
+ fprintf_unfiltered (tmp_error_stream,
+ "Cannot insert hardware breakpoint %d.\n"
+ "You may have requested too many hardware breakpoints.\n",
+ b->number);
+ }
+ else
+ {
+ 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->address, 1, tmp_error_stream);
+ fprintf_filtered (tmp_error_stream, ": %s.\n",
+ safe_strerror (val));
+ }
+
+ fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
target_terminal_ours_for_output ();
- warning ("Cannot insert breakpoint %d:", b->number);
- memory_error (val, b->address); /* which bombs us out */
+ error_stream(tmp_error_stream);
}
else
b->inserted = 1;
if (bs->breakpoint_at == bpt)
{
bs->breakpoint_at = NULL;
-
- /* we'd call bpstat_clear_actions, but that free's stuff and due
- to the multiple pointers pointing to one item with no
- reference counts found anywhere through out the bpstat's (how
- do you spell fragile?), we don't want to free things twice --
- better a memory leak than a corrupt malloc pool! */
- bs->commands = NULL;
bs->old_val = NULL;
+ /* bs->commands will be freed later. */
}
/* On the chance that someone will soon try again to delete this same
bp, we mark it as deleted before freeing its storage. */
return;
}
- save_selected_frame = selected_frame;
- save_selected_frame_level = frame_relative_level (selected_frame);
+ save_selected_frame = deprecated_selected_frame;
+ save_selected_frame_level = frame_relative_level (deprecated_selected_frame);
select_frame (fr);
}
projects / deliverable / binutils-gdb.git / blobdiff