rpms
/
gdb
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
gdb/gdb-6.3-ctorline-20050120.p...

682 lines
22 KiB
Diff
Raw Blame History

2005-01-20 Jeff Johnston <jjohnstn@redhat.com>
* symtab.h (find_line_pc): Change prototype to new api
which returns a list of pc values and the number of list elements.
* symtab.c (find_line_pc): Change function to new api which
returns a list of pc values. Support recognizing a base ctor
or dtor and finding an additional pc value for the in-charge
ctor or dtor accordingly.
(find_line_common): Change api to accept a start_index argument
which determines where to start searching from in the line table.
(find_line_by_pc): New function.
* breakpoint.c (resolve_sal_pc_list): New function.
(breakpoint_sals_to_pc): Support multiple pc values for a
line in a ctor/dtor.
(gdb_breakpoint): Change call to find_line_pc to use new api.
(break_command_1): Move resolve_sals_to_pc earlier due to the
fact it now can extend the sal list.
* mi/mi-cmd-disas.c (mi_cmd_disassemble): Change call to
find_line_pc to new api.
* tui/tui-layout.c (extract_display_start_addr): Ditto.
* tui/tui-win.c (make_visible_with_new_height): Ditto.
* tui/tui-winsource.c (tui_update_source_windows_with_addr): Ditto.
2007-09-22 Jan Kratochvil <jan.kratochvil@redhat.com>
* symtab.c (find_line_pc): Support also the `$allocate' and `$delete'
variants. Support searching for the `$base' name even if the bare name
was found first.
* breakpoint.c (breakpoint_sals_to_pc): Support more than two returned
PC values.
2007-09-25 Jan Kratochvil <jan.kratochvil@redhat.com>
* breakpoint.c (breakpoint_sals_to_pc): New parameter ADDR_STRING_P.
Expand also *ADDR_STRING_P if multiple PCs were found.
(break_command_1, do_captured_breakpoint): Pass also the ADDR_STRING
variable to be updated.
2007-10-05 Jan Kratochvil <jan.kratochvil@redhat.com>
* breakpoint.c (breakpoint_sals_to_pc): Provide "%42" suffix to the
multiple-PC breakpoints' ADDR_STRINGs.
(breakpoint_re_set_one): New variables ID_S, ID, PC_LIST, NUM_PC_VALUES.
Parse the "%42" suffix of the multiple-PC breakpoints's ADDR_STRINGs.
2007-10-14 Jan Kratochvil <jan.kratochvil@redhat.com>
Port to GDB-6.7.
Index: gdb-6.7/gdb/mi/mi-cmd-disas.c
===================================================================
--- gdb-6.7.orig/gdb/mi/mi-cmd-disas.c 2007-08-23 20:08:48.000000000 +0200
+++ gdb-6.7/gdb/mi/mi-cmd-disas.c 2007-10-14 23:26:23.000000000 +0200
@@ -143,11 +143,18 @@ mi_cmd_disassemble (char *command, char
if (line_seen && file_seen)
{
+ CORE_ADDR *pc_list;
+ int num_pc_values;
+
s = lookup_symtab (file_string);
if (s == NULL)
error (_("mi_cmd_disassemble: Invalid filename."));
- if (!find_line_pc (s, line_num, &start))
+ if (!find_line_pc (s, line_num, &pc_list, &num_pc_values))
error (_("mi_cmd_disassemble: Invalid line number"));
+ /* FIXME: What do we do with multiple pc values for ctors/dtors
+ under mi? */
+ start = pc_list[0];
+ xfree (pc_list);
if (find_pc_partial_function (start, NULL, &low, &high) == 0)
error (_("mi_cmd_disassemble: No function contains specified address"));
}
Index: gdb-6.7/gdb/tui/tui-layout.c
===================================================================
--- gdb-6.7.orig/gdb/tui/tui-layout.c 2007-08-23 20:08:50.000000000 +0200
+++ gdb-6.7/gdb/tui/tui-layout.c 2007-10-14 23:26:23.000000000 +0200
@@ -516,7 +516,8 @@ extract_display_start_addr (void)
{
enum tui_layout_type cur_layout = tui_current_layout ();
CORE_ADDR addr;
- CORE_ADDR pc;
+ CORE_ADDR *pc_list;
+ int num_pc_values;
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
switch (cur_layout)
@@ -525,8 +526,11 @@ extract_display_start_addr (void)
case SRC_DATA_COMMAND:
find_line_pc (cursal.symtab,
TUI_SRC_WIN->detail.source_info.start_line_or_addr.u.line_no,
- &pc);
- addr = pc;
+ &pc_list, &num_pc_values);
+ /* FIXME: What do we do with multiple pc values for ctors/dtors or
+ inlined functions? */
+ addr = pc_list[0];
+ xfree (pc_list);
break;
case DISASSEM_COMMAND:
case SRC_DISASSEM_COMMAND:
Index: gdb-6.7/gdb/tui/tui-win.c
===================================================================
--- gdb-6.7.orig/gdb/tui/tui-win.c 2007-08-23 20:08:50.000000000 +0200
+++ gdb-6.7/gdb/tui/tui-win.c 2007-10-14 23:26:23.000000000 +0200
@@ -1359,8 +1359,16 @@ make_visible_with_new_height (struct tui
}
else
{
+ CORE_ADDR *pc_list;
+ int num_pc_values;
line.loa = LOA_ADDRESS;
- find_line_pc (s, cursal.line, &line.u.addr);
+ if (find_line_pc (s, cursal.line, &pc_list, &num_pc_values))
+ {
+ /* FIXME: What do we do with multiple pc values for
+ ctors/dtors and inlined functions? */
+ line.u.addr = pc_list[0];
+ xfree (pc_list);
+ }
}
tui_update_source_window (win_info, s, line, TRUE);
}
Index: gdb-6.7/gdb/tui/tui-winsource.c
===================================================================
--- gdb-6.7.orig/gdb/tui/tui-winsource.c 2007-08-23 20:08:50.000000000 +0200
+++ gdb-6.7/gdb/tui/tui-winsource.c 2007-10-14 23:26:23.000000000 +0200
@@ -173,14 +173,21 @@ tui_update_source_windows_with_addr (COR
void
tui_update_source_windows_with_line (struct symtab *s, int line)
{
- CORE_ADDR pc;
+ CORE_ADDR pc = 0;
+ CORE_ADDR *pc_list;
+ int num_pc_values;
struct tui_line_or_address l;
switch (tui_current_layout ())
{
case DISASSEM_COMMAND:
case DISASSEM_DATA_COMMAND:
- find_line_pc (s, line, &pc);
+ /* FIXME: What do we do with multiple pc values for ctors/dtors? */
+ if (find_line_pc (s, line, &pc_list, &num_pc_values))
+ {
+ pc = pc_list[0];
+ xfree (pc_list);
+ }
tui_update_source_windows_with_addr (pc);
break;
default:
@@ -189,7 +196,12 @@ tui_update_source_windows_with_line (str
tui_show_symtab_source (s, l, FALSE);
if (tui_current_layout () == SRC_DISASSEM_COMMAND)
{
- find_line_pc (s, line, &pc);
+ /* FIXME: What do we do with multiple pc values for ctors/dtors? */
+ if (find_line_pc (s, line, &pc_list, &num_pc_values))
+ {
+ pc = pc_list[0];
+ xfree (pc_list);
+ }
tui_show_disassem (pc);
}
break;
Index: gdb-6.7/gdb/symtab.c
===================================================================
--- gdb-6.7.orig/gdb/symtab.c 2007-10-12 22:35:58.000000000 +0200
+++ gdb-6.7/gdb/symtab.c 2007-10-14 23:26:23.000000000 +0200
@@ -73,7 +73,9 @@ static void sources_info (char *, int);
static void output_source_filename (const char *, int *);
-static int find_line_common (struct linetable *, int, int *);
+static int find_line_common (struct linetable *, int, int, int *);
+
+static int find_line_by_pc (struct linetable *, CORE_ADDR, int *);
/* This one is used by linespec.c */
@@ -2252,6 +2254,9 @@ find_pc_line (CORE_ADDR pc, int notcurre
/* Find line number LINE in any symtab whose name is the same as
SYMTAB.
+ If INDEX is non-NULL, use the value as the starting index in the
+ linetable to start at.
+
If found, return the symtab that contains the linetable in which it was
found, set *INDEX to the index in the linetable of the best entry
found, and set *EXACT_MATCH nonzero if the value returned is an
@@ -2268,13 +2273,19 @@ find_line_symtab (struct symtab *symtab,
so far seen. */
int best_index;
+ int start_index;
struct linetable *best_linetable;
struct symtab *best_symtab;
+ if (index)
+ start_index = *index;
+ else
+ start_index = 0;
+
/* First try looking it up in the given symtab. */
best_linetable = LINETABLE (symtab);
best_symtab = symtab;
- best_index = find_line_common (best_linetable, line, &exact);
+ best_index = find_line_common (best_linetable, line, start_index, &exact);
if (best_index < 0 || !exact)
{
/* Didn't find an exact match. So we better keep looking for
@@ -2305,7 +2316,7 @@ find_line_symtab (struct symtab *symtab,
if (strcmp (symtab->filename, s->filename) != 0)
continue;
l = LINETABLE (s);
- ind = find_line_common (l, line, &exact);
+ ind = find_line_common (l, line, start_index, &exact);
if (ind >= 0)
{
if (exact)
@@ -2341,13 +2352,23 @@ done:
Returns zero for invalid line number (and sets the PC to 0).
The source file is specified with a struct symtab. */
+static CORE_ADDR empty_pc_list = (CORE_ADDR)0;
+
int
-find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
+find_line_pc (struct symtab *symtab, int line, CORE_ADDR **pc_array,
+ int *num_elements)
{
struct linetable *l;
- int ind;
+ int ind = 0;
+ char *name;
+ CORE_ADDR main_pc;
+ struct minimal_symbol *minsym;
+ struct minimal_symbol *minsym2;
+
+
+ *pc_array = &empty_pc_list;
+ *num_elements = 0;
- *pc = 0;
if (symtab == 0)
return 0;
@@ -2355,7 +2376,73 @@ find_line_pc (struct symtab *symtab, int
if (symtab != NULL)
{
l = LINETABLE (symtab);
- *pc = l->item[ind].pc;
+ main_pc = l->item[ind].pc;
+ *pc_array = xmalloc (sizeof (CORE_ADDR) * 3);
+ *num_elements = 0;
+ (*pc_array)[(*num_elements)++] = main_pc;
+ minsym = lookup_minimal_symbol_by_pc (main_pc);
+ if (minsym != NULL && minsym->ginfo.language == language_cplus)
+ {
+ char *src = minsym->ginfo.language_specific.cplus_specific.demangled_name;
+ char *src_point = strchr (src, '(');
+ char *s, *point;
+ /* Keep "" last as the trimming part always matches it. */
+ const char *variants[] = {"$base","$allocate","$delete",""};
+ int i;
+
+ if (src_point != NULL)
+ {
+ char *dst = xmalloc (strlen (src) + strlen ("$allocate") + 1);
+ char *dst_point = dst + (src_point - src);
+
+ memcpy (dst, src, src_point - src);
+
+ /* Trim out any variant markers there first. */
+ for (i = 0; i < ARRAY_SIZE (variants); i++)
+ {
+ size_t len = strlen (variants[i]);
+
+ if (dst_point - dst >= len
+ && memcmp (dst_point - len, variants[i], len) == 0)
+ {
+ dst_point -= len;
+ /* In fact it should not be needed here. */
+ break;
+ }
+ }
+
+ /* And now try to append all of them. */
+ for (i = 0; i < ARRAY_SIZE (variants); i++)
+ {
+ size_t len = strlen (variants[i]);
+ struct minimal_symbol *minsym2;
+
+ memcpy (dst_point, variants[i], len);
+ strcpy (dst_point + len, src_point);
+
+ minsym2 = lookup_minimal_symbol (dst, NULL, NULL);
+ if (minsym2 != NULL)
+ {
+ /* We have recognized we have a ctor or dtor and have
+ located our line in the not-in-charge version. We
+ also have located the in-charge version's minsym.
+ From this, we can find the index for the first line
+ line in the in-charge ctor/dtor and then search forward
+ for the specified line, thereby finding the 2nd match. */
+ int exact;
+ int ind = find_line_by_pc (l, minsym2->ginfo.value.address,
+ &exact);
+ if (ind >= 0)
+ {
+ ind = find_line_common (l, line, ind, &exact);
+ if (ind >= 0 && l->item[ind].pc != main_pc)
+ (*pc_array)[(*num_elements)++] = l->item[ind].pc;
+ }
+ }
+ }
+ xfree (dst);
+ }
+ }
return 1;
}
else
@@ -2373,12 +2460,22 @@ find_line_pc_range (struct symtab_and_li
CORE_ADDR *endptr)
{
CORE_ADDR startaddr;
+ CORE_ADDR *pc_list;
+ int num_pc_values;
struct symtab_and_line found_sal;
startaddr = sal.pc;
- if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
+ if (startaddr == 0
+ && !find_line_pc (sal.symtab, sal.line, &pc_list, &num_pc_values))
return 0;
+ /* FIXME: have to handle ctors/dtors where line equates to multiple
+ pc ranges. */
+ if (startaddr == 0)
+ startaddr = pc_list[0];
+
+ xfree (pc_list);
+
/* This whole function is based on address. For example, if line 10 has
two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
"info line *0x123" should say the line goes from 0x100 to 0x200
@@ -2408,7 +2505,7 @@ find_line_pc_range (struct symtab_and_li
Set *EXACT_MATCH nonzero if the value returned is an exact match. */
static int
-find_line_common (struct linetable *l, int lineno,
+find_line_common (struct linetable *l, int lineno, int start_index,
int *exact_match)
{
int i;
@@ -2427,7 +2524,7 @@ find_line_common (struct linetable *l, i
return -1;
len = l->nitems;
- for (i = 0; i < len; i++)
+ for (i = start_index; i < len; i++)
{
struct linetable_entry *item = &(l->item[i]);
@@ -2451,6 +2548,52 @@ find_line_common (struct linetable *l, i
return best_index;
}
+/* Given a line table and a pc value, return the index into the line
+ table for the line with pc >= specified pc value.
+ Return -1 if none is found. The value is >= 0 if it is an index.
+
+ Set *EXACT_MATCH nonzero if the value returned is an exact match. */
+
+static int
+find_line_by_pc (struct linetable *l, CORE_ADDR pc,
+ int *exact_match)
+{
+ int i;
+ int len;
+
+ /* BEST is the smallest linenumber > LINENO so far seen,
+ or 0 if none has been seen so far.
+ BEST_INDEX identifies the item for it. */
+
+ if (l == 0)
+ return -1;
+
+ len = l->nitems;
+ for (i = 0; i < len; i++)
+ {
+ struct linetable_entry *item = &(l->item[i]);
+
+ /* Return the first (lowest address) entry which matches or
+ exceeds the given pc value. */
+ if (item->pc == pc)
+ {
+ *exact_match = 1;
+ return i;
+ }
+
+ if (item->pc > pc)
+ {
+ *exact_match = 0;
+ return i;
+ }
+ }
+
+ /* If we got here, we didn't get a match. */
+
+ *exact_match = 0;
+ return -1;
+}
+
int
find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
{
Index: gdb-6.7/gdb/symtab.h
===================================================================
--- gdb-6.7.orig/gdb/symtab.h 2007-08-23 20:08:45.000000000 +0200
+++ gdb-6.7/gdb/symtab.h 2007-10-14 23:26:23.000000000 +0200
@@ -1271,13 +1271,16 @@ extern struct symtab_and_line find_pc_se
/* Given a symtab and line number, return the pc there. */
-extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
+extern int find_line_pc (struct symtab *, int, CORE_ADDR **, int *);
extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
CORE_ADDR *);
extern void resolve_sal_pc (struct symtab_and_line *);
+extern void resolve_sal_pc_list (struct symtab_and_line *, CORE_ADDR **,
+ int *);
+
/* Given a string, return the line specified by it. For commands like "list"
and "breakpoint". */
Index: gdb-6.7/gdb/breakpoint.c
===================================================================
--- gdb-6.7.orig/gdb/breakpoint.c 2007-10-13 05:29:58.000000000 +0200
+++ gdb-6.7/gdb/breakpoint.c 2007-10-14 23:26:23.000000000 +0200
@@ -5325,12 +5325,70 @@ parse_breakpoint_sals (char **address,
static void
breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
- char *address)
+ char *address, char ***addr_string_p)
{
- int i;
- for (i = 0; i < sals->nelts; i++)
- {
- resolve_sal_pc (&sals->sals[i]);
+ int i, j, incr;
+ int num_pc_values = 1;
+
+ /* If a line has multiple pc values, we want to create an sal for
+ each pc value so we will end up creating n breakpoints. */
+ for (i = 0; i < sals->nelts; i+=incr)
+ {
+ CORE_ADDR *pc_list;
+ incr = 1;
+
+ resolve_sal_pc_list (&sals->sals[i], &pc_list, &num_pc_values);
+ if (num_pc_values != 0)
+ sals->sals[i].pc = pc_list[0];
+ if (num_pc_values > 1)
+ {
+ struct symtab_and_line *new_sals =
+ xmalloc ((sals->nelts + num_pc_values - 1)
+ * sizeof (struct symtab_and_line));
+ char **new_addr_string;
+ char *addr_string_base;
+
+ /* Expand the SALS array. */
+ memcpy (new_sals, sals->sals, (i + 1)
+ * sizeof (struct symtab_and_line));
+ /* The one returned SALS entry is copied for all the PCs. */
+ for (j = 1; j < num_pc_values; ++j)
+ {
+ memcpy (&(new_sals[i + j]), &sals->sals[i],
+ sizeof (struct symtab_and_line));
+ }
+ xfree (sals->sals);
+ sals->sals = new_sals;
+ sals->nelts += num_pc_values - 1;
+ for (j = 1; j < num_pc_values; ++j)
+ {
+ sals->sals[i + j].pc = pc_list[j];
+ }
+
+ /* Expand the *ADDR_STRING_P array. */
+ new_addr_string = xmalloc ((sals->nelts + num_pc_values - 1)
+ * sizeof *new_addr_string);
+ memcpy (new_addr_string, *addr_string_p,
+ (i + 1) * sizeof *new_addr_string);
+ /* The existing *ADDR_STRING_P entry must be copied for all the
+ multiple PCs. BREAKPOINT_RE_SET will follow the new trailing "%id"
+ syntax so it will get resolved right even later. Do not use the
+ unambiguous NULL values (resolved to "0x%x" by CREATE_BREAKPOINTS)
+ as the address may change for the shared libraries. */
+ addr_string_base = (*addr_string_p)[i];
+ for (j = 0; j < num_pc_values; ++j)
+ new_addr_string[i + j] = xstrprintf ("%s%%%d", addr_string_base, j);
+ xfree (addr_string_base);
+ memcpy (&new_addr_string[i + num_pc_values], &(*addr_string_p)[i + 1],
+ (sals->nelts - (i + num_pc_values)) * sizeof *new_addr_string);
+ xfree (*addr_string_p);
+ *addr_string_p = new_addr_string;
+
+ incr = num_pc_values;
+ }
+
+ if (num_pc_values != 0)
+ xfree (pc_list);
/* It's possible for the PC to be nonzero, but still an illegal
value on some targets.
@@ -5465,6 +5523,10 @@ break_command_1 (char *arg, int flag, in
if (!pending)
{
+ /* Resolve all line numbers to PC's and verify that the addresses
+ are ok for the target. */
+ breakpoint_sals_to_pc (&sals, addr_start, &addr_string);
+
/* Make sure that all storage allocated to SALS gets freed. */
make_cleanup (xfree, sals.sals);
@@ -5495,11 +5557,6 @@ break_command_1 (char *arg, int flag, in
make_cleanup (xfree, addr_string[i]);
}
- /* Resolve all line numbers to PC's and verify that the addresses
- are ok for the target. */
- 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. */
@@ -5675,7 +5732,7 @@ do_captured_breakpoint (struct ui_out *u
error (_("Garbage %s following breakpoint address"), address_end);
/* Resolve all line numbers to PC's. */
- breakpoint_sals_to_pc (&sals, args->address);
+ breakpoint_sals_to_pc (&sals, args->address, &addr_string);
/* Verify that conditions can be parsed, before setting any
breakpoints. */
@@ -5732,14 +5789,16 @@ gdb_breakpoint (char *address, char *con
void
resolve_sal_pc (struct symtab_and_line *sal)
{
- CORE_ADDR pc;
+ CORE_ADDR *pc_list;
+ int num_pc_values;
if (sal->pc == 0 && sal->symtab != NULL)
{
- if (!find_line_pc (sal->symtab, sal->line, &pc))
+ if (!find_line_pc (sal->symtab, sal->line, &pc_list, &num_pc_values))
error (_("No line %d in file \"%s\"."),
sal->line, sal->symtab->filename);
- sal->pc = pc;
+ sal->pc = pc_list[0];
+ xfree (pc_list);
}
if (sal->section == 0 && sal->symtab != NULL)
@@ -5776,6 +5835,54 @@ resolve_sal_pc (struct symtab_and_line *
}
}
+/* Helper function for break_command_1 and disassemble_command. */
+
+void
+resolve_sal_pc_list (struct symtab_and_line *sal, CORE_ADDR **pc_list,
+ int *num_pc_values)
+{
+ *num_pc_values = 0;
+ if (sal->pc == 0 && sal->symtab != NULL)
+ {
+ if (!find_line_pc (sal->symtab, sal->line, pc_list, num_pc_values))
+ error ("No line %d in file \"%s\".",
+ sal->line, sal->symtab->filename);
+ sal->pc = (*pc_list)[0];
+ }
+
+ 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);
+ if (bv != NULL)
+ {
+ b = BLOCKVECTOR_BLOCK (bv, index);
+ sym = block_function (b);
+ if (sym != NULL)
+ {
+ fixup_symbol_section (sym, sal->symtab->objfile);
+ sal->section = SYMBOL_BFD_SECTION (sym);
+ }
+ else
+ {
+ /* It really is worthwhile to have the section, so we'll just
+ have to look harder. This case can be executed if we have
+ line numbers but no functions (as can happen in assembly
+ source). */
+
+ struct minimal_symbol *msym;
+
+ msym = lookup_minimal_symbol_by_pc (sal->pc);
+ if (msym)
+ sal->section = SYMBOL_BFD_SECTION (msym);
+ }
+ }
+ }
+}
void
break_command (char *arg, int from_tty)
{
@@ -7320,6 +7427,8 @@ breakpoint_re_set_one (void *bint)
int *not_found_ptr = NULL;
struct symtabs_and_lines sals;
char *s;
+ char *id_s;
+ int id = -1;
enum enable_state save_enable;
switch (b->type)
@@ -7380,11 +7489,44 @@ breakpoint_re_set_one (void *bint)
set_language (b->language);
input_radix = b->input_radix;
s = b->addr_string;
+ for (id_s = s + strlen (s) - 1; id_s >= s; id_s--)
+ {
+ if (isdigit (*id_s))
+ continue;
+ if (*id_s == '%')
+ break;
+ id_s = NULL;
+ break;
+ }
+ if (id_s >= s)
+ {
+ s = alloca (id_s - b->addr_string + 1);
+ memcpy (s, b->addr_string, id_s - b->addr_string);
+ s[id_s - b->addr_string] = 0;
+ id = atoi (id_s + 1);
+ }
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]);
+ CORE_ADDR *pc_list;
+ int num_pc_values;
+
+ resolve_sal_pc_list (&sals.sals[i], &pc_list, &num_pc_values);
+ if (num_pc_values > 0)
+ {
+ if (id != -1)
+ {
+ /* The number of PC values should not usually change. */
+ if (id >= num_pc_values)
+ {
+ delete_breakpoint (b);
+ return 0;
+ }
+ sals.sals[i].pc = pc_list[id];
+ }
+ xfree (pc_list);
+ }
/* Reparse conditions, they might contain references to the
old symtab. */
Reference in New Issue View Git Blame Copy Permalink