mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-03-01 13:26:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

add _siglongjmp to list of longjmp breakpoints.

Browse Source
This commit is contained in:
David Taylor 1997-12-31 07:36:28 +00:00
parent 47d9c13912
commit 6b038bd9e6
2 changed files with 231 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gdb/ChangeLog
View File

@ -1,3 +1,8 @@
Wed Dec 31 10:33:15 1997 David Taylor <taylor@texas.cygnus.com>
* breakpoint.c (breakpoint_re_set): add _siglongjmp to list of
longjmp breakpoints.
Mon Dec 29 21:25:34 1997 Mark Alexander <marka@cygnus.com>
* dve3900-rom.c: New file to support Densan DVE-R3900/20 board.

335
gdb/breakpoint.c
View File

@ -1,5 +1,5 @@
/* Everything about breakpoints, for GDB.
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
Free Software Foundation, Inc.
This file is part of GDB.
@ -36,6 +36,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "gdb_string.h"
#include "demangle.h"
#include "annotate.h"
#include "symfile.h"
#include "objfiles.h"
/* local function prototypes */
@ -100,10 +102,10 @@ static struct breakpoint *
set_raw_breakpoint PARAMS ((struct symtab_and_line));
static void
check_duplicates PARAMS ((CORE_ADDR));
check_duplicates PARAMS ((CORE_ADDR, asection *));
static void
describe_other_breakpoints PARAMS ((CORE_ADDR));
describe_other_breakpoints PARAMS ((CORE_ADDR, asection *));
static void
breakpoints_info PARAMS ((char *, int));
@ -181,6 +183,10 @@ do_enable_breakpoint PARAMS ((struct breakpoint *, enum bpdisp));
extern int addressprint; /* Print machine addresses? */
#if defined (GET_LONGJMP_TARGET) || defined (SOLIB_ADD)
static int internal_breakpoint_number = -1;
#endif
/* Are we executing breakpoint commands? */
static int executing_breakpoint_commands;
@ -195,6 +201,16 @@ static int executing_breakpoint_commands;
b? (tmp=b->next, 1): 0; \
b = tmp)
/* True if SHIFT_INST_REGS defined, false otherwise. */
int must_shift_inst_regs =
#if defined(SHIFT_INST_REGS)
1
#else
0
#endif
;
/* True if breakpoint hit counts should be displayed in breakpoint info. */
int show_breakpoint_hit_counts = 1;
@ -507,7 +523,30 @@ insert_breakpoints ()
if (b->type == bp_hardware_breakpoint)
val = target_insert_hw_breakpoint(b->address, b->shadow_contents);
else
val = target_insert_breakpoint(b->address, b->shadow_contents);
{
/* Check to see if breakpoint is in an overlay section;
if so, we should set the breakpoint at the LMA address.
Only if the section is currently mapped should we ALSO
set a break at the VMA address. */
if (overlay_debugging && b->section &&
section_is_overlay (b->section))
{
CORE_ADDR addr;
addr = overlay_unmapped_address (b->address, b->section);
val = target_insert_breakpoint (addr, b->shadow_contents);
/* This would be the time to check val, to see if the
breakpoint write to the load address succeeded.
However, this might be an ordinary occurrance, eg. if
the unmapped overlay is in ROM. */
val = 0; /* in case unmapped address failed */
if (section_is_mapped (b->section))
val = target_insert_breakpoint (b->address,
b->shadow_contents);
}
else /* ordinary (non-overlay) address */
val = target_insert_breakpoint(b->address, b->shadow_contents);
}
if (val)
{
/* Can't set the breakpoint. */
@ -563,8 +602,14 @@ insert_breakpoints ()
within_current_scope = 1;
else
{
struct frame_info *fi =
find_frame_addr_in_frame_chain (b->watchpoint_frame);
struct frame_info *fi;
/* There might be no current frame at this moment if we are
resuming from a step over a breakpoint.
Set up current frame before trying to find the watchpoint
frame. */
get_current_frame ();
fi = find_frame_addr_in_frame_chain (b->watchpoint_frame);
within_current_scope = (fi != NULL);
if (within_current_scope)
select_frame (fi, -1);
@ -617,11 +662,7 @@ insert_breakpoints ()
Hardware watchpoint %d deleted because the program has left the block in\n\
which its expression is valid.\n", b->number);
if (b->related_breakpoint)
{
b->related_breakpoint->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
}
b->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
b->disposition = del_at_next_stop;
}
@ -667,7 +708,30 @@ remove_breakpoint (b)
if (b->type == bp_hardware_breakpoint)
val = target_remove_hw_breakpoint(b->address, b->shadow_contents);
else
val = target_remove_breakpoint(b->address, b->shadow_contents);
{
/* Check to see if breakpoint is in an overlay section;
if so, we should remove the breakpoint at the LMA address.
If that is not equal to the raw address, then we should
presumable remove the breakpoint there as well. */
if (overlay_debugging && b->section &&
section_is_overlay (b->section))
{
CORE_ADDR addr;
addr = overlay_unmapped_address (b->address, b->section);
val = target_remove_breakpoint (addr, b->shadow_contents);
/* This would be the time to check val, to see if the
shadow breakpoint write to the load address succeeded.
However, this might be an ordinary occurrance, eg. if
the unmapped overlay is in ROM. */
val = 0; /* in case unmapped address failed */
if (section_is_mapped (b->section))
val = target_remove_breakpoint (b->address,
b->shadow_contents);
}
else /* ordinary (non-overlay) address */
val = target_remove_breakpoint(b->address, b->shadow_contents);
}
if (val)
return val;
b->inserted = 0;
@ -688,11 +752,17 @@ remove_breakpoint (b)
at that address. */
if (v->lval == lval_memory)
{
int addr, len;
int addr, len, type;
addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
len = TYPE_LENGTH (VALUE_TYPE (v));
val = target_remove_watchpoint (addr, len, b->type);
type = 0;
if (b->type == bp_read_watchpoint)
type = 1;
else if (b->type == bp_access_watchpoint)
type = 2;
val = target_remove_watchpoint (addr, len, type);
if (val == -1)
b->inserted = 1;
val = 0;
@ -778,10 +848,36 @@ breakpoint_here_p (pc)
register struct breakpoint *b;
ALL_BREAKPOINTS (b)
if (b->enable != disabled
&& b->enable != shlib_disabled
&& b->address == pc)
return 1;
if (b->enable == enabled
&& b->address == pc) /* bp is enabled and matches pc */
if (overlay_debugging &&
section_is_overlay (b->section) &&
!section_is_mapped (b->section))
continue; /* unmapped overlay -- can't be a match */
else
return 1;
return 0;
}
/* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(), but it
only returns true if there is actually a breakpoint inserted at PC. */
int
breakpoint_inserted_here_p (pc)
CORE_ADDR pc;
{
register struct breakpoint *b;
ALL_BREAKPOINTS (b)
if (b->inserted
&& b->address == pc) /* bp is inserted and matches pc */
if (overlay_debugging &&
section_is_overlay (b->section) &&
!section_is_mapped (b->section))
continue; /* unmapped overlay -- can't be a match */
else
return 1;
return 0;
}
@ -795,12 +891,15 @@ int
frame_in_dummy (frame)
struct frame_info *frame;
{
#ifdef CALL_DUMMY
#ifdef USE_GENERIC_DUMMY_FRAMES
return generic_pc_in_call_dummy (frame->pc, frame->frame);
#else
struct breakpoint *b;
#ifdef CALL_DUMMY
ALL_BREAKPOINTS (b)
{
static unsigned LONGEST dummy[] = CALL_DUMMY;
static ULONGEST dummy[] = CALL_DUMMY;
if (b->type == bp_call_dummy
&& b->frame == frame->frame
@ -813,6 +912,7 @@ frame_in_dummy (frame)
&& frame->pc <= b->address)
return 1;
}
#endif /* GENERIC_DUMMY_FRAMES */
#endif /* CALL_DUMMY */
return 0;
}
@ -835,7 +935,12 @@ breakpoint_thread_match (pc, pid)
&& b->enable != shlib_disabled
&& b->address == pc
&& (b->thread == -1 || b->thread == thread))
return 1;
if (overlay_debugging &&
section_is_overlay (b->section) &&
!section_is_mapped (b->section))
continue; /* unmapped overlay -- can't be a match */
else
return 1;
return 0;
}
@ -1214,11 +1319,7 @@ watchpoint_check (p)
Watchpoint %d deleted because the program has left the block in\n\
which its expression is valid.\n", bs->breakpoint_at->number);
if (b->related_breakpoint)
{
b->related_breakpoint->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
}
b->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
b->disposition = del_at_next_stop;
return WP_DELETED;
@ -1272,10 +1373,8 @@ bpstat_stop_status (pc, not_a_breakpoint)
{
register struct breakpoint *b, *temp;
CORE_ADDR bp_addr;
#if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
/* True if we've hit a breakpoint (as opposed to a watchpoint). */
int real_breakpoint = 0;
#endif
/* Root of the chain of bpstat's */
struct bpstats root_bs[1];
/* Pointer to the last thing in the chain currently. */
@ -1297,9 +1396,12 @@ bpstat_stop_status (pc, not_a_breakpoint)
&& b->type != bp_hardware_watchpoint
&& b->type != bp_read_watchpoint
&& b->type != bp_access_watchpoint
&& b->type != bp_hardware_breakpoint
&& b->address != bp_addr)
continue;
&& b->type != bp_hardware_breakpoint) /* a non-watchpoint bp */
if (b->address != bp_addr || /* address doesn't match or */
(overlay_debugging && /* overlay doesn't match */
section_is_overlay (b->section) &&
!section_is_mapped (b->section)))
continue;
if (b->type == bp_hardware_breakpoint
&& b->address != (bp_addr - DECR_PC_AFTER_HW_BREAK))
@ -1347,11 +1449,7 @@ bpstat_stop_status (pc, not_a_breakpoint)
/* Error from catch_errors. */
printf_filtered ("Watchpoint %d deleted.\n", b->number);
if (b->related_breakpoint)
{
b->related_breakpoint->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
}
b->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
b->disposition = del_at_next_stop;
/* We've already printed what needs to be printed. */
bs->print_it = print_it_done;
@ -1398,21 +1496,15 @@ bpstat_stop_status (pc, not_a_breakpoint)
/* Error from catch_errors. */
printf_filtered ("Watchpoint %d deleted.\n", b->number);
if (b->related_breakpoint)
{
b->related_breakpoint->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
}
b->enable = disable;
b->related_breakpoint->disposition = del_at_next_stop;
b->disposition = del_at_next_stop;
/* We've already printed what needs to be printed. */
bs->print_it = print_it_done;
break;
}
}
#if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
else
else if (DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs)
real_breakpoint = 1;
#endif
if (b->frame && b->frame != (get_current_frame ())->frame)
bs->stop = 0;
@ -1463,8 +1555,8 @@ bpstat_stop_status (pc, not_a_breakpoint)
bs->next = NULL; /* Terminate the chain */
bs = root_bs->next; /* Re-grab the head of the chain */
#if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
if (bs)
if ((DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs) && bs)
{
if (real_breakpoint)
{
@ -1476,7 +1568,6 @@ bpstat_stop_status (pc, not_a_breakpoint)
#endif /* No SHIFT_INST_REGS. */
}
}
#endif /* DECR_PC_AFTER_BREAK != 0. */
/* The value of a hardware watchpoint hasn't changed, but the
intermediate memory locations we are watching may have. */
@ -1807,7 +1898,7 @@ breakpoint_1 (bnum, allflag)
last_addr = b->address;
if (b->source_file)
{
sym = find_pc_function (b->address);
sym = find_pc_sect_function (b->address, b->section);
if (sym)
{
fputs_filtered ("in ", gdb_stdout);
@ -1927,29 +2018,34 @@ maintenance_info_breakpoints (bnum_exp, from_tty)
/* Print a message describing any breakpoints set at PC. */
static void
describe_other_breakpoints (pc)
register CORE_ADDR pc;
describe_other_breakpoints (pc, section)
CORE_ADDR pc;
asection *section;
{
register int others = 0;
register struct breakpoint *b;
ALL_BREAKPOINTS (b)
if (b->address == pc)
others++;
if (overlay_debugging == 0 ||
b->section == section)
others++;
if (others > 0)
{
printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
ALL_BREAKPOINTS (b)
if (b->address == pc)
{
others--;
printf_filtered
("%d%s%s ",
b->number,
((b->enable == disabled || b->enable == shlib_disabled)
? " (disabled)" : ""),
(others > 1) ? "," : ((others == 1) ? " and" : ""));
}
if (overlay_debugging == 0 ||
b->section == section)
{
others--;
printf_filtered
("%d%s%s ",
b->number,
((b->enable == disabled || b->enable == shlib_disabled)
? " (disabled)" : ""),
(others > 1) ? "," : ((others == 1) ? " and" : ""));
}
printf_filtered ("also set at pc ");
print_address_numeric (pc, 1, gdb_stdout);
printf_filtered (".\n");
@ -1977,8 +2073,9 @@ set_default_breakpoint (valid, addr, symtab, line)
This is so that the bpt instruction is only inserted once. */
static void
check_duplicates (address)
check_duplicates (address, section)
CORE_ADDR address;
asection *section;
{
register struct breakpoint *b;
register int count = 0;
@ -1989,7 +2086,8 @@ check_duplicates (address)
ALL_BREAKPOINTS (b)
if (b->enable != disabled
&& b->enable != shlib_disabled
&& b->address == address)
&& b->address == address
&& (overlay_debugging == 0 || b->section == section))
{
count++;
b->duplicate = count > 1;
@ -2020,6 +2118,7 @@ set_raw_breakpoint (sal)
else
b->source_file = savestring (sal.symtab->filename,
strlen (sal.symtab->filename));
b->section = sal.section;
b->language = current_language->la_language;
b->input_radix = input_radix;
b->thread = -1;
@ -2045,14 +2144,12 @@ set_raw_breakpoint (sal)
b1->next = b;
}
check_duplicates (sal.pc);
check_duplicates (sal.pc, sal.section);
breakpoints_changed ();
return b;
}
static int internal_breakpoint_number = -1;
#ifdef GET_LONGJMP_TARGET
static void
@ -2062,6 +2159,7 @@ create_longjmp_breakpoint (func_name)
struct symtab_and_line sal;
struct breakpoint *b;
INIT_SAL (&sal); /* initialize to zeroes */
if (func_name != NULL)
{
struct minimal_symbol *m;
@ -2072,12 +2170,7 @@ create_longjmp_breakpoint (func_name)
else
return;
}
else
sal.pc = 0;
sal.symtab = NULL;
sal.line = 0;
sal.section = find_pc_overlay (sal.pc);
b = set_raw_breakpoint (sal);
if (!b) return;
@ -2105,7 +2198,7 @@ enable_longjmp_breakpoint()
if (b->type == bp_longjmp)
{
b->enable = enabled;
check_duplicates (b->address);
check_duplicates (b->address, b->section);
}
}
@ -2119,7 +2212,7 @@ disable_longjmp_breakpoint()
|| b->type == bp_longjmp_resume)
{
b->enable = disabled;
check_duplicates (b->address);
check_duplicates (b->address, b->section);
}
}
@ -2141,9 +2234,9 @@ create_solib_event_breakpoint (address)
struct breakpoint *b;
struct symtab_and_line sal;
INIT_SAL (&sal); /* initialize to zeroes */
sal.pc = address;
sal.symtab = NULL;
sal.line = 0;
sal.section = find_pc_overlay (sal.pc);
b = set_raw_breakpoint (sal);
b->number = internal_breakpoint_number--;
b->disposition = donttouch;
@ -2232,7 +2325,7 @@ set_longjmp_resume_breakpoint(pc, frame)
b->frame = frame->frame;
else
b->frame = 0;
check_duplicates (b->address);
check_duplicates (b->address, b->section);
return;
}
}
@ -2366,8 +2459,7 @@ break_command_1 (arg, flag, from_tty)
sals.sals = NULL;
sals.nelts = 0;
sal.line = sal.pc = sal.end = 0;
sal.symtab = 0;
INIT_SAL (&sal); /* initialize to zeroes */
/* If no arg given, or if first arg is 'if ', use the default breakpoint. */
@ -2381,6 +2473,7 @@ break_command_1 (arg, flag, from_tty)
sal.pc = default_breakpoint_address;
sal.line = default_breakpoint_line;
sal.symtab = default_breakpoint_symtab;
sal.section = find_pc_overlay (sal.pc);
sals.sals[0] = sal;
sals.nelts = 1;
}
@ -2493,7 +2586,7 @@ break_command_1 (arg, flag, from_tty)
sal = sals.sals[i];
if (from_tty)
describe_other_breakpoints (sal.pc);
describe_other_breakpoints (sal.pc, sal.section);
b = set_raw_breakpoint (sal);
set_breakpoint_count (breakpoint_count + 1);
@ -2513,7 +2606,6 @@ break_command_1 (arg, flag, from_tty)
b->enable = enabled;
b->disposition = tempflag ? del : donttouch;
mention (b);
}
@ -2533,7 +2625,7 @@ resolve_sal_pc (sal)
{
CORE_ADDR pc;
if (sal->pc == 0 && sal->symtab != 0)
if (sal->pc == 0 && sal->symtab != NULL)
{
pc = find_line_pc (sal->symtab, sal->line);
if (pc == 0)
@ -2541,6 +2633,23 @@ resolve_sal_pc (sal)
sal->line, sal->symtab->filename);
sal->pc = pc;
}
if (sal->section == 0 && sal->symtab != NULL)
{
struct blockvector *bv;
struct block *b;
struct symbol *sym;
int index;
bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
b = BLOCKVECTOR_BLOCK (bv, index);
sym = block_function (b);
if (sym != NULL)
{
fixup_symbol_section (sym, sal->symtab->objfile);
sal->section = SYMBOL_BFD_SECTION (block_function (b));
}
}
}
void
@ -2598,13 +2707,11 @@ watch_command_1 (arg, accessflag, from_tty)
char *cond_start = NULL;
char *cond_end = NULL;
struct expression *cond = NULL;
int i, other_type_used, target_resources_ok;
int i, other_type_used, target_resources_ok = 0;
enum bptype bp_type;
int mem_cnt = 0;
sal.pc = 0;
sal.symtab = NULL;
sal.line = 0;
INIT_SAL (&sal); /* initialize to zeroes */
/* Parse arguments. */
innermost_block = NULL;
@ -2687,15 +2794,15 @@ watch_command_1 (arg, accessflag, from_tty)
expression. */
if (innermost_block)
{
struct breakpoint *scope_breakpoint;
struct symtab_and_line scope_sal;
if (prev_frame)
{
scope_sal.pc = get_frame_pc (prev_frame);
scope_sal.symtab = NULL;
scope_sal.line = 0;
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);
set_breakpoint_count (breakpoint_count + 1);
scope_breakpoint->number = breakpoint_count;
@ -2903,8 +3010,8 @@ map_catch_names (args, function)
#if 0
if (function (p))
{
struct sal_chain *next
= (struct sal_chain *)alloca (sizeof (struct sal_chain));
struct sal_chain *next = (struct sal_chain *)
alloca (sizeof (struct sal_chain));
next->next = sal_chain;
next->sal = get_catch_sal (p);
sal_chain = next;
@ -3053,8 +3160,7 @@ catch_command_1 (arg, tempflag, from_tty)
char *save_arg;
int i;
sal.line = sal.pc = sal.end = 0;
sal.symtab = 0;
INIT_SAL (&sal); /* initialize to zeroes */
/* If no arg given, or if first arg is 'if ', all active catch clauses
are breakpointed. */
@ -3100,7 +3206,7 @@ catch_command_1 (arg, tempflag, from_tty)
sal = sals.sals[i];
if (from_tty)
describe_other_breakpoints (sal.pc);
describe_other_breakpoints (sal.pc, sal.section);
b = set_raw_breakpoint (sal);
set_breakpoint_count (breakpoint_count + 1);
@ -3125,7 +3231,7 @@ catch_command_1 (arg, tempflag, from_tty)
struct breakpoint *
set_breakpoint_sal (sal)
struct symtab_and_line sal;
struct symtab_and_line sal;
{
struct breakpoint *b;
b = set_raw_breakpoint (sal);
@ -3189,10 +3295,11 @@ clear_command (arg, from_tty)
}
else
{
sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
sals.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
INIT_SAL (&sal); /* initialize to zeroes */
sal.line = default_breakpoint_line;
sal.symtab = default_breakpoint_symtab;
sal.pc = 0;
if (sal.symtab == 0)
error ("No source file specified.");
@ -3206,9 +3313,12 @@ clear_command (arg, from_tty)
But if sal.pc is zero, clear all bpts on specified line. */
sal = sals.sals[i];
found = (struct breakpoint *) 0;
while (breakpoint_chain
&& (sal.pc
? breakpoint_chain->address == sal.pc
? (breakpoint_chain->address == sal.pc &&
(overlay_debugging == 0 ||
breakpoint_chain->section == sal.section))
: (breakpoint_chain->source_file != NULL
&& sal.symtab != NULL
&& STREQ (breakpoint_chain->source_file,
@ -3228,7 +3338,9 @@ clear_command (arg, from_tty)
&& b->next->type != bp_read_watchpoint
&& b->next->type != bp_access_watchpoint
&& (sal.pc
? b->next->address == sal.pc
? (b->next->address == sal.pc &&
(overlay_debugging == 0 ||
b->next->section == sal.section))
: (b->next->source_file != NULL
&& sal.symtab != NULL
&& STREQ (b->next->source_file, sal.symtab->filename)
@ -3310,7 +3422,7 @@ delete_breakpoint (bpt)
break;
}
check_duplicates (bpt->address);
check_duplicates (bpt->address, bpt->section);
/* If this breakpoint was inserted, and there is another breakpoint
at the same address, we need to insert the other breakpoint. */
if (bpt->inserted
@ -3320,6 +3432,7 @@ delete_breakpoint (bpt)
{
ALL_BREAKPOINTS (b)
if (b->address == bpt->address
&& b->section == bpt->section
&& !b->duplicate
&& b->enable != disabled
&& b->enable != shlib_disabled)
@ -3367,6 +3480,7 @@ delete_command (arg, from_tty)
char *arg;
int from_tty;
{
struct breakpoint *b, *temp;
if (arg == 0)
{
@ -3375,8 +3489,10 @@ delete_command (arg, from_tty)
|| (breakpoint_chain && query ("Delete all breakpoints? ")))
{
/* No arg; clear all breakpoints. */
while (breakpoint_chain)
delete_breakpoint (breakpoint_chain);
ALL_BREAKPOINTS_SAFE(b, temp)
/* do not delete call-dummy breakpoint unles explicitly named! */
if (b->type != bp_call_dummy)
delete_breakpoint (b);
}
}
else
@ -3455,8 +3571,7 @@ breakpoint_re_set_one (bint)
strlen (sals.sals[i].symtab->filename));
b->line_number = sals.sals[i].line;
b->address = sals.sals[i].pc;
check_duplicates (b->address);
check_duplicates (b->address, b->section);
mention (b);
@ -3464,6 +3579,7 @@ breakpoint_re_set_one (bint)
rather than once for every breakpoint. */
breakpoints_changed ();
}
b->section = sals.sals[i].section;
b->enable = save_enable; /* Restore it, this worked. */
}
free ((PTR)sals.sals);
@ -3560,6 +3676,7 @@ breakpoint_re_set ()
create_longjmp_breakpoint ("longjmp");
create_longjmp_breakpoint ("_longjmp");
create_longjmp_breakpoint ("siglongjmp");
create_longjmp_breakpoint ("_siglongjmp");
create_longjmp_breakpoint (NULL);
#endif
@ -3690,7 +3807,7 @@ disable_breakpoint (bpt)
bpt->enable = disabled;
check_duplicates (bpt->address);
check_duplicates (bpt->address, bpt->section);
if (modify_breakpoint_hook)
modify_breakpoint_hook (bpt);
@ -3745,7 +3862,7 @@ do_enable_breakpoint (bpt, disposition)
bpt->enable = enabled;
bpt->disposition = disposition;
check_duplicates (bpt->address);
check_duplicates (bpt->address, bpt->section);
breakpoints_changed ();
if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||