/* 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->address), 0);
+ b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
if (*arg)
error ("Junk at end of expression");
}
|| b->type == bp_access_watchpoint)
continue;
/* bp in memory? */
- if (!b->inserted)
+ if (!b->loc->inserted)
continue;
/* Addresses and length of the part of the breakpoint that
we need to copy. */
breakpoint values. BREAKPOINT_FROM_PC still manages to
correctly determine the breakpoints memory address and size
for these targets. */
- bp_addr = b->address;
+ bp_addr = b->loc->address;
bp_size = 0;
if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
continue;
}
memcpy (myaddr + bp_addr - memaddr,
- b->shadow_contents + bptoffset, bp_size);
+ b->loc->shadow_contents + bptoffset, bp_size);
if (bp_addr > memaddr)
{
&& b->type != bp_catch_exec
&& b->type != bp_catch_throw
&& b->type != bp_catch_catch
- && !b->inserted
- && !b->duplicate)
+ && !b->loc->inserted
+ && !b->loc->duplicate)
{
/* "Normal" instruction breakpoint: either the standard
trap-instruction bp (bp_breakpoint), or a
/* No overlay handling: just set the breakpoint. */
if (b->type == bp_hardware_breakpoint)
- val = target_insert_hw_breakpoint (b->address,
- b->shadow_contents);
+ val = target_insert_hw_breakpoint (b->loc->address,
+ b->loc->shadow_contents);
else
- val = target_insert_breakpoint (b->address, b->shadow_contents);
+ val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
}
else
{
b->number);
else
{
- CORE_ADDR addr = overlay_unmapped_address (b->address,
+ CORE_ADDR addr = overlay_unmapped_address (b->loc->address,
b->section);
/* Set a software (trap) breakpoint at the LMA. */
- val = target_insert_breakpoint (addr, b->shadow_contents);
+ val = target_insert_breakpoint (addr, b->loc->shadow_contents);
if (val != 0)
fprintf_unfiltered (tmp_error_stream,
"Overlay breakpoint %d failed: in ROM?",
{
/* Yes. This overlay section is mapped into memory. */
if (b->type == bp_hardware_breakpoint)
- val = target_insert_hw_breakpoint (b->address,
- b->shadow_contents);
+ val = target_insert_hw_breakpoint (b->loc->address,
+ b->loc->shadow_contents);
else
- val = target_insert_breakpoint (b->address,
- b->shadow_contents);
+ val = target_insert_breakpoint (b->loc->address,
+ b->loc->shadow_contents);
}
else
{
{
/* Can't set the breakpoint. */
#if defined (DISABLE_UNSETTABLE_BREAK)
- if (DISABLE_UNSETTABLE_BREAK (b->address))
+ if (DISABLE_UNSETTABLE_BREAK (b->loc->address))
{
/* See also: disable_breakpoints_in_shlibs. */
val = 0;
b->number);
fprintf_filtered (tmp_error_stream,
"Error accessing memory address ");
- print_address_numeric (b->address, 1, tmp_error_stream);
+ print_address_numeric (b->loc->address, 1, tmp_error_stream);
fprintf_filtered (tmp_error_stream, ": %s.\n",
safe_strerror (val));
}
}
}
else
- b->inserted = 1;
+ b->loc->inserted = 1;
if (val)
return_val = val; /* remember failure */
}
else if (ep_is_exception_catchpoint (b)
- && !b->inserted
- && !b->duplicate)
+ && !b->loc->inserted
+ && !b->loc->duplicate)
{
/* If we get here, we must have a callback mechanism for exception
events -- with g++ style embedded label support, we insert
ordinary breakpoints and not catchpoints. */
- val = target_insert_breakpoint (b->address, b->shadow_contents);
+ val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
if (val)
{
/* Couldn't set breakpoint for some reason */
b->number);
fprintf_filtered (tmp_error_stream,
"Error accessing memory address ");
- print_address_numeric (b->address, 1, tmp_error_stream);
+ print_address_numeric (b->loc->address, 1, tmp_error_stream);
fprintf_filtered (tmp_error_stream, ": %s.\n",
safe_strerror (val));
b->enable_state = bp_disabled;
do_cleanups (cleanups);
if (val != 0 && val != -1)
{
- b->inserted = 1;
+ b->loc->inserted = 1;
}
/* Check if something went wrong; val == 0 can be ignored */
if (val == -1)
b->type == bp_read_watchpoint ||
b->type == bp_access_watchpoint)
&& b->disposition != disp_del_at_next_stop
- && !b->inserted
- && !b->duplicate)
+ && !b->loc->inserted
+ && !b->loc->duplicate)
{
struct frame_info *saved_frame;
int saved_level, within_current_scope;
value_release_to_mark (mark);
b->val_chain = v;
- b->inserted = 1;
+ b->loc->inserted = 1;
/* Look at each value on the value chain. */
for (; v; v = v->next)
watches below, and removing a
watchpoint we didn't insert could have
adverse effects. */
- b->inserted = 0;
+ b->loc->inserted = 0;
}
val = 0;
}
}
/* Failure to insert a watchpoint on any memory value in the
value chain brings us here. */
- if (!b->inserted)
+ if (!b->loc->inserted)
{
remove_breakpoint (b, mark_uninserted);
hw_breakpoint_error = 1;
else if ((b->type == bp_catch_fork
|| b->type == bp_catch_vfork
|| b->type == bp_catch_exec)
- && !b->inserted
- && !b->duplicate)
+ && !b->loc->inserted
+ && !b->loc->duplicate)
{
char *prefix = xstrprintf ("warning: inserting catchpoint %d: ",
b->number);
if (val < 0)
b->enable_state = bp_disabled;
else
- b->inserted = 1;
+ b->loc->inserted = 1;
}
}
ALL_BREAKPOINTS (b)
{
- if (b->inserted)
+ if (b->loc->inserted)
{
val = remove_breakpoint (b, mark_uninserted);
if (val != 0)
ALL_BREAKPOINTS (b)
{
- if (b->inserted
+ if (b->loc->inserted
&& (b->type == bp_hardware_watchpoint
|| b->type == bp_read_watchpoint
|| b->type == bp_access_watchpoint))
inferior_ptid = pid_to_ptid (pid);
ALL_BREAKPOINTS (b)
{
- if (b->inserted)
+ if (b->loc->inserted)
{
remove_breakpoint (b, mark_inserted);
if (b->type == bp_hardware_breakpoint)
- val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
+ val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
else
- val = target_insert_breakpoint (b->address, b->shadow_contents);
+ val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
if (val != 0)
{
do_cleanups (old_chain);
(b->type == bp_catch_vfork) ||
(b->type == bp_catch_fork))
{
- b->address = (CORE_ADDR) NULL;
+ b->loc->address = (CORE_ADDR) NULL;
continue;
}
unnecessary. A call to breakpoint_re_set_one always recomputes
the breakpoint's address from scratch, or deletes it if it can't.
So I think this assignment could be deleted without effect. */
- b->address = (CORE_ADDR) NULL;
+ b->loc->address = (CORE_ADDR) NULL;
}
/* FIXME what about longjmp breakpoints? Re-create them here? */
create_overlay_event_breakpoint ("_ovly_debug_event");
inferior_ptid = pid_to_ptid (pid);
ALL_BREAKPOINTS (b)
{
- if (b->inserted)
+ if (b->loc->inserted)
{
val = remove_breakpoint (b, mark_inserted);
if (val != 0)
/* No overlay handling: just remove the breakpoint. */
if (b->type == bp_hardware_breakpoint)
- val = target_remove_hw_breakpoint (b->address,
- b->shadow_contents);
+ val = target_remove_hw_breakpoint (b->loc->address,
+ b->loc->shadow_contents);
else
- val = target_remove_breakpoint (b->address, b->shadow_contents);
+ val = target_remove_breakpoint (b->loc->address, b->loc->shadow_contents);
}
else
{
/* Yes -- overlay event support is not active, so we
should have set a breakpoint at the LMA. Remove it.
*/
- CORE_ADDR addr = overlay_unmapped_address (b->address,
+ CORE_ADDR addr = overlay_unmapped_address (b->loc->address,
b->section);
/* Ignore any failures: if the LMA is in ROM, we will
have already warned when we failed to insert it. */
if (b->type != bp_hardware_breakpoint)
- target_remove_hw_breakpoint (addr, b->shadow_contents);
+ target_remove_hw_breakpoint (addr, b->loc->shadow_contents);
else
- target_remove_breakpoint (addr, b->shadow_contents);
+ target_remove_breakpoint (addr, b->loc->shadow_contents);
}
/* Did we set a breakpoint at the VMA?
If so, we will have marked the breakpoint 'inserted'. */
- if (b->inserted)
+ if (b->loc->inserted)
{
/* Yes -- remove it. Previously we did not bother to
remove the breakpoint if the section had been
unmapped, but let's not rely on that being safe. We
don't know what the overlay manager might do. */
if (b->type == bp_hardware_breakpoint)
- val = target_remove_hw_breakpoint (b->address,
- b->shadow_contents);
+ val = target_remove_hw_breakpoint (b->loc->address,
+ b->loc->shadow_contents);
else
- val = target_remove_breakpoint (b->address,
- b->shadow_contents);
+ val = target_remove_breakpoint (b->loc->address,
+ b->loc->shadow_contents);
}
else
{
}
if (val)
return val;
- b->inserted = (is == mark_inserted);
+ b->loc->inserted = (is == mark_inserted);
}
else if ((b->type == bp_hardware_watchpoint ||
b->type == bp_read_watchpoint ||
b->type == bp_access_watchpoint)
&& b->enable_state == bp_enabled
- && !b->duplicate)
+ && !b->loc->duplicate)
{
struct value *v;
struct value *n;
- b->inserted = (is == mark_inserted);
+ b->loc->inserted = (is == mark_inserted);
/* Walk down the saved value chain. */
for (v = b->val_chain; v; v = v->next)
{
val = target_remove_watchpoint (addr, len, type);
if (val == -1)
- b->inserted = 1;
+ b->loc->inserted = 1;
val = 0;
}
}
}
/* Failure to remove any of the hardware watchpoints comes here. */
- if ((is == mark_uninserted) && (b->inserted))
+ if ((is == mark_uninserted) && (b->loc->inserted))
warning ("Could not remove hardware watchpoint %d.",
b->number);
b->type == bp_catch_vfork ||
b->type == bp_catch_exec)
&& b->enable_state == bp_enabled
- && !b->duplicate)
+ && !b->loc->duplicate)
{
val = -1;
switch (b->type)
}
if (val)
return val;
- b->inserted = (is == mark_inserted);
+ b->loc->inserted = (is == mark_inserted);
}
else if ((b->type == bp_catch_catch ||
b->type == bp_catch_throw)
&& b->enable_state == bp_enabled
- && !b->duplicate)
+ && !b->loc->duplicate)
{
- val = target_remove_breakpoint (b->address, b->shadow_contents);
+ val = target_remove_breakpoint (b->loc->address, b->loc->shadow_contents);
if (val)
return val;
- b->inserted = (is == mark_inserted);
+ b->loc->inserted = (is == mark_inserted);
}
else if (ep_is_exception_catchpoint (b)
- && b->inserted /* sometimes previous insert doesn't happen */
+ && b->loc->inserted /* sometimes previous insert doesn't happen */
&& b->enable_state == bp_enabled
- && !b->duplicate)
+ && !b->loc->duplicate)
{
- val = target_remove_breakpoint (b->address, b->shadow_contents);
+ val = target_remove_breakpoint (b->loc->address, b->loc->shadow_contents);
if (val)
return val;
- b->inserted = (is == mark_inserted);
+ b->loc->inserted = (is == mark_inserted);
}
return 0;
struct breakpoint *b;
ALL_BREAKPOINTS (b)
- b->inserted = 0;
+ b->loc->inserted = 0;
}
/* Clear the "inserted" flag in all breakpoints and delete any
ALL_BREAKPOINTS_SAFE (b, temp)
{
- b->inserted = 0;
+ b->loc->inserted = 0;
switch (b->type)
{
ALL_BREAKPOINTS (b)
if ((b->enable_state == bp_enabled
|| b->enable_state == bp_permanent)
- && b->address == pc) /* bp is enabled and matches pc */
+ && b->loc->address == pc) /* bp is enabled and matches pc */
{
if (overlay_debugging
&& section_is_overlay (b->section)
struct breakpoint *b;
ALL_BREAKPOINTS (b)
- if (b->inserted
- && b->address == pc) /* bp is inserted and matches pc */
+ if (b->loc->inserted
+ && b->loc->address == pc) /* bp is inserted and matches pc */
{
if (overlay_debugging
&& section_is_overlay (b->section)
/* 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->address
+ >= (b->loc->address
- DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * DEPRECATED_REGISTER_SIZE))
- && get_frame_pc (frame) <= b->address)
+ && get_frame_pc (frame) <= b->loc->address)
return 1;
}
return 0;
if (b->enable_state != bp_disabled
&& b->enable_state != bp_shlib_disabled
&& b->enable_state != bp_call_disabled
- && b->address == pc
+ && b->loc->address == pc
&& (b->thread == -1 || b->thread == thread))
{
if (overlay_debugging
{
case bp_breakpoint:
case bp_hardware_breakpoint:
- if (bs->breakpoint_at->address != bs->breakpoint_at->requested_address)
- breakpoint_adjustment_warning (bs->breakpoint_at->requested_address,
- bs->breakpoint_at->address,
+ if (bs->breakpoint_at->loc->address != bs->breakpoint_at->loc->requested_address)
+ breakpoint_adjustment_warning (bs->breakpoint_at->loc->requested_address,
+ bs->breakpoint_at->loc->address,
bs->breakpoint_at->number, 1);
annotate_breakpoint (bs->breakpoint_at->number);
ui_out_text (uiout, "\nBreakpoint ");
&& b->type != bp_catch_catch
&& b->type != bp_catch_throw) /* a non-watchpoint bp */
{
- if (b->address != bp_addr) /* address doesn't match */
+ if (b->loc->address != bp_addr) /* address doesn't match */
continue;
if (overlay_debugging /* unmapped overlay section */
&& section_is_overlay (b->section)
if (b->type == bp_hardware_breakpoint)
{
- if (b->address != (*pc - DECR_PC_AFTER_HW_BREAK))
+ if (b->loc->address != (*pc - DECR_PC_AFTER_HW_BREAK))
continue;
if (overlay_debugging /* unmapped overlay section */
&& section_is_overlay (b->section)
struct breakpoint *b;
ALL_BREAKPOINTS (b)
if ((b->enable_state == bp_enabled) &&
- (b->inserted) &&
+ (b->loc->inserted) &&
((b->type == bp_hardware_watchpoint) ||
(b->type == bp_read_watchpoint) ||
(b->type == bp_access_watchpoint)))
if (addressprint)
{
annotate_field (4);
- ui_out_field_core_addr (uiout, "addr", b->address);
+ ui_out_field_core_addr (uiout, "addr", b->loc->address);
}
annotate_field (5);
- *last_addr = b->address;
+ *last_addr = b->loc->address;
if (b->source_file)
{
- sym = find_pc_sect_function (b->address, b->section);
+ sym = find_pc_sect_function (b->loc->address, b->section);
if (sym)
{
ui_out_text (uiout, "in ");
}
else
{
- print_address_symbolic (b->address, stb->stream, demangle, "");
+ print_address_symbolic (b->loc->address, stb->stream, demangle, "");
ui_out_field_stream (uiout, "at", stb);
}
break;
struct breakpoint *b;
ALL_BREAKPOINTS (b)
- if (b->address == pc) /* address match / overlay match */
+ if (b->loc->address == pc) /* address match / overlay match */
if (!overlay_debugging || b->section == section)
others++;
if (others > 0)
{
printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
ALL_BREAKPOINTS (b)
- if (b->address == pc) /* address match / overlay match */
+ if (b->loc->address == pc) /* address match / overlay match */
if (!overlay_debugging || b->section == section)
{
others--;
struct breakpoint *b;
int count = 0;
struct breakpoint *perm_bp = 0;
- CORE_ADDR address = bpt->address;
+ CORE_ADDR address = bpt->loc->address;
asection *section = bpt->section;
if (! breakpoint_address_is_meaningful (bpt))
if (b->enable_state != bp_disabled
&& b->enable_state != bp_shlib_disabled
&& b->enable_state != bp_call_disabled
- && b->address == address /* address / overlay match */
+ && b->loc->address == address /* address / overlay match */
&& (!overlay_debugging || b->section == section)
&& breakpoint_address_is_meaningful (b))
{
}
count++;
- b->duplicate = count > 1;
+ b->loc->duplicate = count > 1;
}
/* If we found a permanent breakpoint at this address, go over the
duplicates. */
if (perm_bp)
{
- perm_bp->duplicate = 0;
+ perm_bp->loc->duplicate = 0;
/* Permanent breakpoint should always be inserted. */
- if (! perm_bp->inserted)
+ if (! perm_bp->loc->inserted)
internal_error (__FILE__, __LINE__,
"allegedly permanent breakpoint is not "
"actually inserted");
ALL_BREAKPOINTS (b)
if (b != perm_bp)
{
- if (b->inserted)
+ if (b->loc->inserted)
internal_error (__FILE__, __LINE__,
"another breakpoint was inserted on top of "
"a permanent breakpoint");
if (b->enable_state != bp_disabled
&& b->enable_state != bp_shlib_disabled
&& b->enable_state != bp_call_disabled
- && b->address == address /* address / overlay match */
+ && b->loc->address == address /* address / overlay match */
&& (!overlay_debugging || b->section == section)
&& breakpoint_address_is_meaningful (b))
- b->duplicate = 1;
+ b->loc->duplicate = 1;
}
}
}
b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
memset (b, 0, sizeof (*b));
- b->requested_address = sal.pc;
- b->address = adjust_breakpoint_address (b->requested_address);
+ b->loc = (struct bp_location *) xmalloc (sizeof (struct bp_location));
+ memset (b->loc, 0, sizeof (*b->loc));
+ b->loc->requested_address = sal.pc;
+ b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
if (sal.symtab == NULL)
b->source_file = NULL;
else
b->enable_state = bp_permanent;
/* By definition, permanent breakpoints are already present in the code. */
- b->inserted = 1;
+ b->loc->inserted = 1;
}
static struct breakpoint *
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->address));
+ xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
return b;
}
if (((b->type == bp_breakpoint) ||
(b->type == bp_hardware_breakpoint)) &&
b->enable_state == bp_enabled &&
- !b->duplicate &&
- PC_SOLIB (b->address))
+ !b->loc->duplicate &&
+ PC_SOLIB (b->loc->address))
{
b->enable_state = bp_shlib_disabled;
if (!silent)
/* Do not reenable the breakpoint if the shared library
is still not mapped in. */
- if (target_read_memory (b->address, buf, 1) == 0)
+ if (target_read_memory (b->loc->address, buf, 1) == 0)
b->enable_state = bp_enabled;
}
}
ALL_BREAKPOINTS (b)
if (b->type == bp_longjmp_resume)
{
- b->requested_address = pc;
- b->address = adjust_breakpoint_address (b->requested_address);
+ b->loc->requested_address = pc;
+ b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
b->enable_state = bp_enabled;
b->frame_id = frame_id;
check_duplicates (b);
if (addressprint || b->source_file == NULL)
{
printf_filtered (" at ");
- print_address_numeric (b->address, 1, gdb_stdout);
+ print_address_numeric (b->loc->address, 1, gdb_stdout);
}
if (b->source_file)
printf_filtered (": file %s, line %d.",
else
/* addr_string has to be used or breakpoint_re_set will delete
me. */
- xasprintf (&b->addr_string, "*0x%s", paddr (b->address));
+ xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
b->cond_string = cond_string[i];
b->ignore_count = ignore_count;
b->enable_state = bp_enabled;
scope_breakpoint->frame_id = get_frame_id (prev_frame);
/* Set the address at which we will stop. */
- scope_breakpoint->requested_address = get_frame_pc (prev_frame);
- scope_breakpoint->address =
- adjust_breakpoint_address (scope_breakpoint->requested_address);
+ scope_breakpoint->loc->requested_address
+ = get_frame_pc (prev_frame);
+ scope_breakpoint->loc->address
+ = adjust_breakpoint_address (scope_breakpoint->loc->requested_address);
/* The scope breakpoint is related to the watchpoint. We
will need to act on them together. */
if (addressprint)
{
annotate_field (4);
- ui_out_field_core_addr (uiout, "addr", b->address);
+ ui_out_field_core_addr (uiout, "addr", b->loc->address);
}
annotate_field (5);
- *last_addr = b->address;
+ *last_addr = b->loc->address;
if (strstr (b->addr_string, "throw") != NULL)
ui_out_field_string (uiout, "what", "exception throw");
else
&& b->type != bp_read_watchpoint
&& b->type != bp_access_watchpoint
/* Not if b is a watchpoint of any sort... */
- && (((sal.pc && (b->address == sal.pc))
+ && (((sal.pc && (b->loc->address == sal.pc))
&& (!section_is_overlay (b->section)
|| b->section == sal.section))
/* Yes, if sal.pc matches b (modulo overlays). */
delete_breakpoint_hook (bpt);
breakpoint_delete_event (bpt->number);
- if (bpt->inserted)
+ if (bpt->loc->inserted)
remove_breakpoint (bpt, mark_inserted);
if (breakpoint_chain == bpt)
check_duplicates (bpt);
/* If this breakpoint was inserted, and there is another breakpoint
at the same address, we need to insert the other breakpoint. */
- if (bpt->inserted
+ if (bpt->loc->inserted
&& bpt->type != bp_hardware_watchpoint
&& bpt->type != bp_read_watchpoint
&& bpt->type != bp_access_watchpoint
&& bpt->type != bp_catch_exec)
{
ALL_BREAKPOINTS (b)
- if (b->address == bpt->address
+ if (b->loc->address == bpt->loc->address
&& b->section == bpt->section
- && !b->duplicate
+ && !b->loc->duplicate
&& b->enable_state != bp_disabled
&& b->enable_state != bp_shlib_disabled
&& b->enable_state != bp_call_disabled)
"a permanent breakpoint");
if (b->type == bp_hardware_breakpoint)
- val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
+ val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
else
- val = target_insert_breakpoint (b->address, b->shadow_contents);
+ val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
/* If there was an error in the insert, print a message, then stop execution. */
if (val != 0)
{
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);
+ print_address_numeric (b->loc->address, 1, tmp_error_stream);
fprintf_filtered (tmp_error_stream, ": %s.\n",
safe_strerror (val));
}
error_stream(tmp_error_stream);
}
else
- b->inserted = 1;
+ b->loc->inserted = 1;
}
}
bp, we mark it as deleted before freeing its storage. */
bpt->type = bp_none;
+ xfree (bpt->loc);
xfree (bpt);
}
}
/* We need to re-set the breakpoint if the address changes... */
- if (b->address != sals.sals[i].pc
+ if (b->loc->address != sals.sals[i].pc
/* ...or new and old breakpoints both have source files, and
the source file name or the line number changes... */
|| (b->source_file != NULL
savestring (sals.sals[i].symtab->filename,
strlen (sals.sals[i].symtab->filename));
b->line_number = sals.sals[i].line;
- b->requested_address = sals.sals[i].pc;
- b->address = adjust_breakpoint_address (b->requested_address);
+ b->loc->requested_address = sals.sals[i].pc;
+ b->loc->address
+ = adjust_breakpoint_address (b->loc->requested_address);
/* Used to check for duplicates here, but that can
cause trouble, as it doesn't check for disabled
projects / deliverable / binutils-gdb.git / commitdiff
