This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: Save the length of inserted breakpoints
> Date: Mon, 17 Apr 2006 15:08:08 -0400
> From: Daniel Jacobowitz <drow@false.org>
>
> On Mon, Apr 17, 2006 at 03:49:29PM +0200, Mark Kettenis wrote:
> > > I've been thinking about having target methods which don't need the
> > > shadow contents (there are definitely several) record the "length" of
> > > the breakpoint as zero; then deprecated_read_memory_nobpt can do the
> > > right thing. Does this sound reasonable? The alternative is to do an
> > > unnecessary read from the target.
> >
> > Absolutely. If the length is zero there are no shadow contents to
> > worry about. But it is probably better to address
> > deprecated_read_memory_nobpt in a seperate patch.
>
> Well, otherwise I get compilation errors. So I've fixed it together
> with this.
>
> On the documentation front, I am quite mortified; I wrote this
> ChangeLog entry at least twice for earlier versions of the patch:
>
> * gdbint.texinfo (Watchpoints, Target Conditionals): Update insert
> and remove breakpoint prototypes.
>
> While they often use the underlying watchpoint registers, hardware
> breakpoints are breakpoints. I've moved these to the Breakpoints
> section, and added some more bits there. Eli, could you take a look
> at that?
>
> I turned out to need a fourth element in the struct :-( But I think
> the result is fairly clear, esp. with the comments and documentation.
> Here's struct bp_target_info:
>
> /* Information used by targets to insert and remove breakpoints. */
>
> struct bp_target_info
> {
> /* Address at which the breakpoint was placed. This is normally the
> same as ADDRESS from the bp_location, except when adjustment
> happens in BREAKPOINT_FROM_PC. The most common form of
> adjustment is stripping an alternate ISA marker from the PC which
> is used to determine the type of breakpoint to insert. */
> CORE_ADDR placed_address;
>
> /* If the breakpoint lives in memory and reading that memory would
> give back the breakpoint, instead of the original contents, then
> the original contents are cached here. Only SHADOW_LEN bytes of
> this buffer are valid, and only when the breakpoint is inserted. */
> gdb_byte shadow_contents[BREAKPOINT_MAX];
>
> /* The length of the data cached in SHADOW_CONTENTS. */
> int shadow_len;
>
> /* The size of the placed breakpoint, according to
> BREAKPOINT_FROM_PC, when the breakpoint was inserted. This is
> generally the same as SHADOW_LEN, unless we did not need
> to read from the target to implement the memory breakpoint
> (e.g. if a remote stub handled the details). We may still
> need the size to remove the breakpoint safely. */
> int placed_size;
> };
>
> Stubs which do read from the target set shadow_len, as of course does
> the generic memory_insert_breakpoint. The remote Z0 support does not;
> one of the benefits of using Z0 is that getting the target memory
> correct is not GDB's problem.
Hmm, if I understand things correctly, the only reason why you need
placed_size, is because we want shadow_len to tell is whether we've
actually saved the contents or not. This is eh, a wee bit ugly.
Actually I think the z0 packet should not include the length of the
breakpoint. The remote stub will have to keep track of the length of
the inserted breakpoint anyway, exactly because it has get the the
target memory correct.
I'm still thinking about a more elegant solution. One would be to
allocate the shadow contents dynamically and make it a NULL pointer if
GDB didn't actually save any shadow contents. Meanwhile, I spropose
you check this in. This issue has been on the table long enough now.
Mark
P.S. Someone should really get rid of tm-sh.h and
DEPRECATED_{BIG|LITTLE}_BREAKPOINT.
> Daniel Jacobowitz
> CodeSourcery
>
> 2006-04-17 Daniel Jacobowitz <dan@codesourcery.com>
>
> * breakpoint.c (deprecated_read_memory_nobpt): Update to use
> shadow_len.
> (insert_bp_location, reattach_breakpoints, remove_breakpoint)
> (delete_breakpoint): Update calls to changed methods.
> (deprecated_insert_raw_breakpoint, deprecated_remove_raw_breakpoint)
> (single_step_breakpoints, insert_single_step_breakpoint)
> (remove_single_step_breakpoints): New.
> * breakpoint.h (struct bp_target_info): New.
> (struct bp_location): Replace shadow_contents with
> target_info and overlay_target_info.
> (deprecated_insert_raw_breakpoint, deprecated_remove_raw_breakpoint)
> (insert_single_step_breakpoint, remove_single_step_breakpoints): New
> prototypes.
> * gdbarch.sh: Forward declare struct bp_target_info in gdbarch.h.
> (memory_insert_breakpoint, memory_remove_breakpoint): Update second
> argument.
> * mem-break.c (default_memory_insert_breakpoint): Update. Set
> placed_address, placed_size, and shadow_len.
> (default_memory_remove_breakpoint): Update. Don't use
> BREAKPOINT_FROM_PC.
> (memory_insert_breakpoint, memory_remove_breakpoint): Update.
> * target.c (update_current_target): Update prototypes for changed
> functions.
> (debug_to_insert_breakpoint, debug_to_remove_breakpoint)
> (debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint):
> Update.
> * target.h: Forward declare struct bp_target_info.
> (struct target_ops): Use a bp_target_info argument for
> to_insert_breakpoint, to_remove_breakpoint,
> to_insert_hw_breakpoint, and to_remove_hw_breakpoint.
> (target_insert_breakpoint, target_remove_breakpoint)
> (target_insert_hw_breakpoint, target_remove_hw_breakpoint)
> (memory_insert_breakpoint, memory_remove_breakpoint)
> (default_memory_insert_breakpoint, default_memory_remove_breakpoint):
> Update.
> * config/i386/nm-i386.h: Forward declare struct bp_target_info.
> (i386_insert_hw_breakpoint, i386_remove_hw_breakpoint): Update.
> (target_insert_hw_breakpoint, target_remove_hw_breakpoint): Likewise.
>
> * gdbarch.c, gdbarch.h: Regenerated.
>
> * alpha-tdep.c (alpha_software_single_step): Use
> insert_single_step_breakpoint and remove_single_step_breakpoints.
> Remove unused statics.
> * arm-tdep.c (arm_software_single_step): Likewise. Add a note.
> * cris-tdep.c (cris_software_single_step): Likewise.
> * mips-tdep.c (mips_software_single_step): Likewise.
> * rs6000-tdep.c (rs6000_software_single_step): Likewise.
> * sparc-tdep.c (sparc_software_single_step): Likewise.
> * wince.c (struct thread_info_struct): Remove step_prev.
> (undoSStep): Use remove_single_step_breakpoints.
> (wince_software_single_step): Use insert_single_step_breakpoint.
>
> * corelow.c (ignore): Remove unneeded prototype. Update arguments.
> * exec.c (ignore): Likewise.
> * sol-thread.c (ignore): Likewise.
>
> * procfs.c (dbx_link_shadow_contents): Delete.
> (dbx_link_bpt): New.
> (procfs_mourn_inferior): Remove it if necessary.
> (remove_dbx_link_breakpoint): Use it.
> (insert_dbx_link_bpt_in_file): Set it.
> (procfs_init_inferior): Don't update dbx_link_bpt_addr.
> * rs6000-nat.c (exec_one_dummy_insn): Use
> deprecated_insert_raw_breakpoint and
> deprecated_remove_raw_breakpoint.
> * solib-irix.c (shadow_contents, breakpoint_addr): Delete.
> (base_breakpoint): New.
> (disable_break): Use it.
> (enable_break): Set it.
>
> * i386-nat.c (i386_insert_hw_breakpoint, i386_remove_hw_breakpoint):
> Update.
> * ia64-tdep.c (ia64_memory_insert_breakpoint)
> (ia64_memory_remove_breakpoint): Likewise.
> * m32r-tdep.c (m32r_memory_insert_breakpoint)
> (m32r_memory_remove_breakpoint): Likewise.
> * monitor.c (monitor_insert_breakpoint, monitor_remove_breakpoint):
> Likewise. Remove unnecessary prototypes. Use placed_address
> and placed_size. Removed useless read from memory.
> * nto-procfs.c (procfs_insert_breakpoint)
> (procfs_remove_breakpoint, procfs_insert_hw_breakpoint)
> (procfs_remove_hw_breakpoint): Update.
> * ocd.c (ocd_insert_breakpoint, ocd_remove_breakpoint): Likewise.
> * ocd.h (ocd_insert_breakpoint, ocd_remove_breakpoint): Likewise.
> * ppc-linux-tdep.c (ppc_linux_memory_remove_breakpoint): Likewise.
> * ppc-tdep.h (ppc_linux_memory_remove_breakpoint): Likewise.
> * remote-e7000.c (e7000_insert_breakpoint)
> (e7000_remove_breakpoint): Likewise.
> * remote-m32r-sdi.c (m32r_insert_breakpoint)
> (m32r_remove_breakpoint): Likewise.
> * remote-mips.c (mips_insert_breakpoint)
> (mips_remove_breakpoint): Likewise.
> * remote-rdp.c (remote_rdp_insert_breakpoint)
> (remote_rdp_remove_breakpoint): Likewise.
> (rdp_step): Use deprecated_insert_raw_breakpoint and
> deprecated_remove_raw_breakpoint.
> * remote-sds.c (sds_insert_breakpoint, sds_remove_breakpoint):
> Update.
> * remote-sim.c (gdbsim_insert_breakpoint, gdbsim_remove_breakpoint):
> Delete.
> (init_gdbsim_ops): Use memory_insert_breakpoint and
> memory_remove_breakpoint.
> * remote-st.c (st2000_insert_breakpoint)
> (st2000_remove_breakpoint): Update. Remove unused
> BREAKPOINT_FROM_PC.
> * remote.c (remote_insert_breakpoint, remote_remove_breakpoint):
> Update. Use placed_address and placed_size.
> (remote_insert_hw_breakpoint, remote_remove_hw_breakpoint): Likewise.
>
> 2006-04-17 Daniel Jacobowitz <dan@codesourcery.com>
>
> * gdbint.texinfo (x86 Watchpoints, Target Conditionals): Update insert
> and remove breakpoint prototypes.
> (Watchpoints): Move description of target_insert_hw_breakpoint and
> target_remove_hw_breakpoint ...
> (Breakpoints): ... to here. Document target_insert_breakpoint and
> target_remove_breakpoint.
>
> ? remove-breakpoint-supply-length-v2.patch
> ? remove-breakpoint-supply-length-v3.patch
> Index: alpha-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/alpha-tdep.c,v
> retrieving revision 1.153
> diff -u -p -r1.153 alpha-tdep.c
> --- alpha-tdep.c 15 Jan 2006 20:53:32 -0000 1.153
> +++ alpha-tdep.c 17 Apr 2006 19:03:19 -0000
> @@ -1493,8 +1493,6 @@ void
> alpha_software_single_step (enum target_signal sig, int insert_breakpoints_p)
> {
> static CORE_ADDR next_pc;
> - typedef char binsn_quantum[BREAKPOINT_MAX];
> - static binsn_quantum break_mem;
> CORE_ADDR pc;
>
> if (insert_breakpoints_p)
> @@ -1502,11 +1500,11 @@ alpha_software_single_step (enum target_
> pc = read_pc ();
> next_pc = alpha_next_pc (pc);
>
> - target_insert_breakpoint (next_pc, break_mem);
> + insert_single_step_breakpoint (next_pc);
> }
> else
> {
> - target_remove_breakpoint (next_pc, break_mem);
> + remove_single_step_breakpoints ();
> write_pc (next_pc);
> }
> }
> Index: arm-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/arm-tdep.c,v
> retrieving revision 1.207
> diff -u -p -r1.207 arm-tdep.c
> --- arm-tdep.c 30 Mar 2006 16:48:47 -0000 1.207
> +++ arm-tdep.c 17 Apr 2006 19:03:19 -0000
> @@ -1849,16 +1849,18 @@ arm_get_next_pc (CORE_ADDR pc)
> static void
> arm_software_single_step (enum target_signal sig, int insert_bpt)
> {
> - static int next_pc; /* State between setting and unsetting. */
> - static char break_mem[BREAKPOINT_MAX]; /* Temporary storage for mem@bpt */
> + /* NOTE: This may insert the wrong breakpoint instruction when
> + single-stepping over a mode-changing instruction, if the
> + CPSR heuristics are used. */
>
> if (insert_bpt)
> {
> - next_pc = arm_get_next_pc (read_register (ARM_PC_REGNUM));
> - target_insert_breakpoint (next_pc, break_mem);
> + CORE_ADDR next_pc = arm_get_next_pc (read_register (ARM_PC_REGNUM));
> +
> + insert_single_step_breakpoint (next_pc);
> }
> else
> - target_remove_breakpoint (next_pc, break_mem);
> + remove_single_step_breakpoints ();
> }
>
> #include "bfd-in2.h"
> Index: breakpoint.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/breakpoint.c,v
> retrieving revision 1.224
> diff -u -p -r1.224 breakpoint.c
> --- breakpoint.c 6 Apr 2006 18:33:05 -0000 1.224
> +++ breakpoint.c 17 Apr 2006 19:03:20 -0000
> @@ -663,16 +663,10 @@ deprecated_read_memory_nobpt (CORE_ADDR
> continue;
> /* Addresses and length of the part of the breakpoint that
> we need to copy. */
> - /* XXXX The m68k, sh and h8300 have different local and remote
> - breakpoint values. BREAKPOINT_FROM_PC still manages to
> - correctly determine the breakpoints memory address and size
> - for these targets. */
> - bp_addr = b->address;
> - bp_size = 0;
> - if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
> - continue;
> + bp_addr = b->target_info.placed_address;
> + bp_size = b->target_info.shadow_len;
> if (bp_size == 0)
> - /* bp isn't valid */
> + /* bp isn't valid, or doesn't shadow memory. */
> continue;
> if (bp_addr + bp_size <= memaddr)
> /* The breakpoint is entirely before the chunk of memory we
> @@ -703,7 +697,7 @@ deprecated_read_memory_nobpt (CORE_ADDR
> }
>
> memcpy (myaddr + bp_addr - memaddr,
> - b->shadow_contents + bptoffset, bp_size);
> + b->target_info.shadow_contents + bptoffset, bp_size);
>
> if (bp_addr > memaddr)
> {
> @@ -793,6 +787,10 @@ insert_bp_location (struct bp_location *
> if (bpt->inserted || bpt->duplicate)
> return 0;
>
> + /* Initialize the target-specific information. */
> + memset (&bpt->target_info, 0, sizeof (bpt->target_info));
> + bpt->target_info.placed_address = bpt->address;
> +
> if (bpt->loc_type == bp_loc_software_breakpoint
> || bpt->loc_type == bp_loc_hardware_breakpoint)
> {
> @@ -804,11 +802,9 @@ insert_bp_location (struct bp_location *
> /* No overlay handling: just set the breakpoint. */
>
> if (bpt->loc_type == bp_loc_hardware_breakpoint)
> - val = target_insert_hw_breakpoint (bpt->address,
> - bpt->shadow_contents);
> + val = target_insert_hw_breakpoint (&bpt->target_info);
> else
> - val = target_insert_breakpoint (bpt->address,
> - bpt->shadow_contents);
> + val = target_insert_breakpoint (&bpt->target_info);
> }
> else
> {
> @@ -827,7 +823,9 @@ insert_bp_location (struct bp_location *
> CORE_ADDR addr = overlay_unmapped_address (bpt->address,
> bpt->section);
> /* Set a software (trap) breakpoint at the LMA. */
> - val = target_insert_breakpoint (addr, bpt->shadow_contents);
> + bpt->overlay_target_info = bpt->target_info;
> + bpt->overlay_target_info.placed_address = addr;
> + val = target_insert_breakpoint (&bpt->overlay_target_info);
> if (val != 0)
> fprintf_unfiltered (tmp_error_stream,
> "Overlay breakpoint %d failed: in ROM?",
> @@ -839,11 +837,9 @@ insert_bp_location (struct bp_location *
> {
> /* Yes. This overlay section is mapped into memory. */
> if (bpt->loc_type == bp_loc_hardware_breakpoint)
> - val = target_insert_hw_breakpoint (bpt->address,
> - bpt->shadow_contents);
> + val = target_insert_hw_breakpoint (&bpt->target_info);
> else
> - val = target_insert_breakpoint (bpt->address,
> - bpt->shadow_contents);
> + val = target_insert_breakpoint (&bpt->target_info);
> }
> else
> {
> @@ -1045,7 +1041,7 @@ in which its expression is valid.\n"),
> /* 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 (bpt->address, bpt->shadow_contents);
> + val = target_insert_breakpoint (&bpt->target_info);
> if (val)
> {
> /* Couldn't set breakpoint for some reason */
> @@ -1240,9 +1236,9 @@ reattach_breakpoints (int pid)
> {
> remove_breakpoint (b, mark_inserted);
> if (b->loc_type == bp_loc_hardware_breakpoint)
> - val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
> + val = target_insert_hw_breakpoint (&b->target_info);
> else
> - val = target_insert_breakpoint (b->address, b->shadow_contents);
> + val = target_insert_breakpoint (&b->target_info);
> /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
> breakpoints. It's wrong for watchpoints, for example. */
> if (val != 0)
> @@ -1446,10 +1442,9 @@ remove_breakpoint (struct bp_location *b
> /* No overlay handling: just remove the breakpoint. */
>
> if (b->loc_type == bp_loc_hardware_breakpoint)
> - val = target_remove_hw_breakpoint (b->address,
> - b->shadow_contents);
> + val = target_remove_hw_breakpoint (&b->target_info);
> else
> - val = target_remove_breakpoint (b->address, b->shadow_contents);
> + val = target_remove_breakpoint (&b->target_info);
> }
> else
> {
> @@ -1460,14 +1455,12 @@ remove_breakpoint (struct bp_location *b
> /* 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,
> - b->section);
> /* Ignore any failures: if the LMA is in ROM, we will
> have already warned when we failed to insert it. */
> if (b->loc_type == bp_loc_hardware_breakpoint)
> - target_remove_hw_breakpoint (addr, b->shadow_contents);
> + target_remove_hw_breakpoint (&b->overlay_target_info);
> else
> - target_remove_breakpoint (addr, b->shadow_contents);
> + target_remove_breakpoint (&b->overlay_target_info);
> }
> /* Did we set a breakpoint at the VMA?
> If so, we will have marked the breakpoint 'inserted'. */
> @@ -1478,11 +1471,9 @@ remove_breakpoint (struct bp_location *b
> unmapped, but let's not rely on that being safe. We
> don't know what the overlay manager might do. */
> if (b->loc_type == bp_loc_hardware_breakpoint)
> - val = target_remove_hw_breakpoint (b->address,
> - b->shadow_contents);
> + val = target_remove_hw_breakpoint (&b->target_info);
> else
> - val = target_remove_breakpoint (b->address,
> - b->shadow_contents);
> + val = target_remove_breakpoint (&b->target_info);
> }
> else
> {
> @@ -1570,8 +1561,7 @@ remove_breakpoint (struct bp_location *b
> && breakpoint_enabled (b->owner)
> && !b->duplicate)
> {
> -
> - val = target_remove_breakpoint (b->address, b->shadow_contents);
> + val = target_remove_breakpoint (&b->target_info);
> if (val)
> return val;
> b->inserted = (is == mark_inserted);
> @@ -1581,8 +1571,7 @@ remove_breakpoint (struct bp_location *b
> && breakpoint_enabled (b->owner)
> && !b->duplicate)
> {
> -
> - val = target_remove_breakpoint (b->address, b->shadow_contents);
> + val = target_remove_breakpoint (&b->target_info);
> if (val)
> return val;
>
> @@ -6852,10 +6841,12 @@ delete_breakpoint (struct breakpoint *bp
> _("another breakpoint was inserted on top of "
> "a permanent breakpoint"));
>
> + memset (&b->loc->target_info, 0, sizeof (b->loc->target_info));
> + b->loc->target_info.placed_address = b->loc->address;
> if (b->type == bp_hardware_breakpoint)
> - val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
> + val = target_insert_hw_breakpoint (&b->loc->target_info);
> else
> - val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
> + val = target_insert_breakpoint (&b->loc->target_info);
>
> /* If there was an error in the insert, print a message, then stop execution. */
> if (val != 0)
> @@ -7658,6 +7649,97 @@ decode_line_spec_1 (char *string, int fu
> error (_("Junk at end of line specification: %s"), string);
> return sals;
> }
> +
> +/* Create and insert a raw software breakpoint at PC. Return an
> + identifier, which should be used to remove the breakpoint later.
> + In general, places which call this should be using something on the
> + breakpoint chain instead; this function should be eliminated
> + someday. */
> +
> +void *
> +deprecated_insert_raw_breakpoint (CORE_ADDR pc)
> +{
> + struct bp_target_info *bp_tgt;
> +
> + bp_tgt = xmalloc (sizeof (struct bp_target_info));
> + memset (bp_tgt, 0, sizeof (struct bp_target_info));
> +
> + bp_tgt->placed_address = pc;
> + if (target_insert_breakpoint (bp_tgt) != 0)
> + {
> + /* Could not insert the breakpoint. */
> + xfree (bp_tgt);
> + return NULL;
> + }
> +
> + return bp_tgt;
> +}
> +
> +/* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
> +
> +int
> +deprecated_remove_raw_breakpoint (void *bp)
> +{
> + struct bp_target_info *bp_tgt = bp;
> + int ret;
> +
> + ret = target_remove_breakpoint (bp_tgt);
> + xfree (bp_tgt);
> +
> + return ret;
> +}
> +
> +/* One (or perhaps two) breakpoints used for software single stepping. */
> +
> +static void *single_step_breakpoints[2];
> +
> +/* Create and insert a breakpoint for software single step. */
> +
> +void
> +insert_single_step_breakpoint (CORE_ADDR next_pc)
> +{
> + void **bpt_p;
> +
> + if (single_step_breakpoints[0] == NULL)
> + bpt_p = &single_step_breakpoints[0];
> + else
> + {
> + gdb_assert (single_step_breakpoints[1] == NULL);
> + bpt_p = &single_step_breakpoints[1];
> + }
> +
> + /* NOTE drow/2006-04-11: A future improvement to this function would be
> + to only create the breakpoints once, and actually put them on the
> + breakpoint chain. That would let us use set_raw_breakpoint. We could
> + adjust the addresses each time they were needed. Doing this requires
> + corresponding changes elsewhere where single step breakpoints are
> + handled, however. So, for now, we use this. */
> +
> + *bpt_p = deprecated_insert_raw_breakpoint (next_pc);
> + if (*bpt_p == NULL)
> + warning (_("Could not insert single-step breakpoint at 0x%s"),
> + paddr_nz (next_pc));
> +}
> +
> +/* Remove and delete any breakpoints used for software single step. */
> +
> +void
> +remove_single_step_breakpoints (void)
> +{
> + gdb_assert (single_step_breakpoints[0] != NULL);
> +
> + /* See insert_single_step_breakpoint for more about this deprecated
> + call. */
> + deprecated_remove_raw_breakpoint (single_step_breakpoints[0]);
> + single_step_breakpoints[0] = NULL;
> +
> + if (single_step_breakpoints[1] != NULL)
> + {
> + deprecated_remove_raw_breakpoint (single_step_breakpoints[1]);
> + single_step_breakpoints[1] = NULL;
> + }
> +}
> +
>
> /* This help string is used for the break, hbreak, tbreak and thbreak commands.
> It is defined as a macro to prevent duplication.
> Index: breakpoint.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/breakpoint.h,v
> retrieving revision 1.36
> diff -u -p -r1.36 breakpoint.h
> --- breakpoint.h 17 Dec 2005 22:33:59 -0000 1.36
> +++ breakpoint.h 17 Apr 2006 19:03:20 -0000
> @@ -185,6 +185,36 @@ enum target_hw_bp_type
> hw_execute = 3 /* Execute HW breakpoint */
> };
>
> +
> +/* Information used by targets to insert and remove breakpoints. */
> +
> +struct bp_target_info
> +{
> + /* Address at which the breakpoint was placed. This is normally the
> + same as ADDRESS from the bp_location, except when adjustment
> + happens in BREAKPOINT_FROM_PC. The most common form of
> + adjustment is stripping an alternate ISA marker from the PC which
> + is used to determine the type of breakpoint to insert. */
> + CORE_ADDR placed_address;
> +
> + /* If the breakpoint lives in memory and reading that memory would
> + give back the breakpoint, instead of the original contents, then
> + the original contents are cached here. Only SHADOW_LEN bytes of
> + this buffer are valid, and only when the breakpoint is inserted. */
> + gdb_byte shadow_contents[BREAKPOINT_MAX];
> +
> + /* The length of the data cached in SHADOW_CONTENTS. */
> + int shadow_len;
> +
> + /* The size of the placed breakpoint, according to
> + BREAKPOINT_FROM_PC, when the breakpoint was inserted. This is
> + generally the same as SHADOW_LEN, unless we did not need
> + to read from the target to implement the memory breakpoint
> + (e.g. if a remote stub handled the details). We may still
> + need the size to remove the breakpoint safely. */
> + int placed_size;
> +};
> +
> /* GDB maintains two types of information about each breakpoint (or
> watchpoint, or other related event). The first type corresponds
> to struct breakpoint; this is a relatively high-level structure
> @@ -242,13 +272,6 @@ struct bp_location
> associated with the address. Used primarily for overlay debugging. */
> asection *section;
>
> - /* "Real" contents of byte where breakpoint has been inserted.
> - Valid only when breakpoints are in the program. Under the complete
> - control of the target insert_breakpoint and remove_breakpoint routines.
> - No other code should assume anything about the value(s) here.
> - Valid only for bp_loc_software_breakpoint. */
> - gdb_byte shadow_contents[BREAKPOINT_MAX];
> -
> /* Address at which breakpoint was requested, either by the user or
> by GDB for internal breakpoints. This will usually be the same
> as ``address'' (above) except for cases in which
> @@ -256,6 +279,12 @@ struct bp_location
> which to place the breakpoint in order to comply with a
> processor's architectual constraints. */
> CORE_ADDR requested_address;
> +
> + /* Details of the placed breakpoint, when inserted. */
> + struct bp_target_info target_info;
> +
> + /* Similarly, for the breakpoint at an overlay's LMA, if necessary. */
> + struct bp_target_info overlay_target_info;
> };
>
> /* This structure is a collection of function pointers that, if available,
> @@ -796,6 +825,16 @@ extern void delete_command (char *arg, i
> remove fails. */
> extern int remove_hw_watchpoints (void);
>
> +/* Manage a software single step breakpoint (or two). Insert may be called
> + twice before remove is called. */
> +extern void insert_single_step_breakpoint (CORE_ADDR);
> +extern void remove_single_step_breakpoints (void);
> +
> +/* Manage manual breakpoints, separate from the normal chain of
> + breakpoints. These functions are used in murky target-specific
> + ways. Please do not add more uses! */
> +extern void *deprecated_insert_raw_breakpoint (CORE_ADDR);
> +extern int deprecated_remove_raw_breakpoint (void *);
>
> /* Indicator of whether exception catchpoints should be nuked between
> runs of a program. */
> Index: corelow.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/corelow.c,v
> retrieving revision 1.55
> diff -u -p -r1.55 corelow.c
> --- corelow.c 25 Feb 2006 04:36:39 -0000 1.55
> +++ corelow.c 17 Apr 2006 19:03:20 -0000
> @@ -86,8 +86,6 @@ static void get_core_registers (int);
>
> static void add_to_thread_list (bfd *, asection *, void *);
>
> -static int ignore (CORE_ADDR, bfd_byte *);
> -
> static int core_file_thread_alive (ptid_t tid);
>
> static void init_core_ops (void);
> @@ -603,7 +601,7 @@ core_xfer_partial (struct target_ops *op
> `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
>
> static int
> -ignore (CORE_ADDR addr, bfd_byte *contents)
> +ignore (struct bp_target_info *bp_tgt)
> {
> return 0;
> }
> Index: cris-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/cris-tdep.c,v
> retrieving revision 1.135
> diff -u -p -r1.135 cris-tdep.c
> --- cris-tdep.c 5 Apr 2006 20:01:19 -0000 1.135
> +++ cris-tdep.c 17 Apr 2006 19:03:21 -0000
> @@ -558,15 +558,6 @@ struct instruction_environment
> int disable_interrupt;
> } inst_env_type;
>
> -/* Save old breakpoints in order to restore the state before a single_step.
> - At most, two breakpoints will have to be remembered. */
> -typedef
> -char binsn_quantum[BREAKPOINT_MAX];
> -static binsn_quantum break_mem[2];
> -static CORE_ADDR next_pc = 0;
> -static CORE_ADDR branch_target_address = 0;
> -static unsigned char branch_break_inserted = 0;
> -
> /* Machine-dependencies in CRIS for opcodes. */
>
> /* Instruction sizes. */
> @@ -2130,7 +2121,7 @@ static void
> cris_software_single_step (enum target_signal ignore, int insert_breakpoints)
> {
> inst_env_type inst_env;
> -
> +
> if (insert_breakpoints)
> {
> /* Analyse the present instruction environment and insert
> @@ -2146,28 +2137,19 @@ cris_software_single_step (enum target_s
> {
> /* Insert at most two breakpoints. One for the next PC content
> and possibly another one for a branch, jump, etc. */
> - next_pc = (CORE_ADDR) inst_env.reg[PC_REGNUM];
> - target_insert_breakpoint (next_pc, break_mem[0]);
> + CORE_ADDR next_pc = (CORE_ADDR) inst_env.reg[PC_REGNUM];
> + insert_single_step_breakpoint (next_pc);
> if (inst_env.branch_found
> && (CORE_ADDR) inst_env.branch_break_address != next_pc)
> {
> - branch_target_address =
> - (CORE_ADDR) inst_env.branch_break_address;
> - target_insert_breakpoint (branch_target_address, break_mem[1]);
> - branch_break_inserted = 1;
> + CORE_ADDR branch_target_address
> + = (CORE_ADDR) inst_env.branch_break_address;
> + insert_single_step_breakpoint (branch_target_address);
> }
> }
> }
> else
> - {
> - /* Remove breakpoints. */
> - target_remove_breakpoint (next_pc, break_mem[0]);
> - if (branch_break_inserted)
> - {
> - target_remove_breakpoint (branch_target_address, break_mem[1]);
> - branch_break_inserted = 0;
> - }
> - }
> + remove_single_step_breakpoints ();
> }
>
> /* Calculates the prefix value for quick offset addressing mode. */
> Index: exec.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/exec.c,v
> retrieving revision 1.60
> diff -u -p -r1.60 exec.c
> --- exec.c 25 Feb 2006 04:36:39 -0000 1.60
> +++ exec.c 17 Apr 2006 19:03:21 -0000
> @@ -59,8 +59,6 @@ static void set_section_command (char *,
>
> static void exec_files_info (struct target_ops *);
>
> -static int ignore (CORE_ADDR, bfd_byte *);
> -
> static void init_exec_ops (void);
>
> void _initialize_exec (void);
> @@ -691,7 +689,7 @@ exec_set_section_address (const char *fi
> breakpoint_init_inferior). */
>
> static int
> -ignore (CORE_ADDR addr, bfd_byte *contents)
> +ignore (struct bp_target_info *bp_tgt)
> {
> return 0;
> }
> Index: gdbarch.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/gdbarch.c,v
> retrieving revision 1.328
> diff -u -p -r1.328 gdbarch.c
> --- gdbarch.c 17 Dec 2005 22:33:59 -0000 1.328
> +++ gdbarch.c 17 Apr 2006 19:03:21 -0000
> @@ -1250,8 +1250,8 @@ gdbarch_dump (struct gdbarch *current_gd
> #ifdef MEMORY_INSERT_BREAKPOINT
> fprintf_unfiltered (file,
> "gdbarch_dump: %s # %s\n",
> - "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
> - XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
> + "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
> + XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt)));
> #endif
> fprintf_unfiltered (file,
> "gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
> @@ -1259,8 +1259,8 @@ gdbarch_dump (struct gdbarch *current_gd
> #ifdef MEMORY_REMOVE_BREAKPOINT
> fprintf_unfiltered (file,
> "gdbarch_dump: %s # %s\n",
> - "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
> - XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
> + "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
> + XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt)));
> #endif
> fprintf_unfiltered (file,
> "gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
> @@ -2934,13 +2934,13 @@ set_gdbarch_adjust_breakpoint_address (s
> }
>
> int
> -gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, gdb_byte *contents_cache)
> +gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
> {
> gdb_assert (gdbarch != NULL);
> gdb_assert (gdbarch->memory_insert_breakpoint != NULL);
> if (gdbarch_debug >= 2)
> fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
> - return gdbarch->memory_insert_breakpoint (addr, contents_cache);
> + return gdbarch->memory_insert_breakpoint (bp_tgt);
> }
>
> void
> @@ -2951,13 +2951,13 @@ set_gdbarch_memory_insert_breakpoint (st
> }
>
> int
> -gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, gdb_byte *contents_cache)
> +gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
> {
> gdb_assert (gdbarch != NULL);
> gdb_assert (gdbarch->memory_remove_breakpoint != NULL);
> if (gdbarch_debug >= 2)
> fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
> - return gdbarch->memory_remove_breakpoint (addr, contents_cache);
> + return gdbarch->memory_remove_breakpoint (bp_tgt);
> }
>
> void
> Index: gdbarch.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/gdbarch.h,v
> retrieving revision 1.284
> diff -u -p -r1.284 gdbarch.h
> --- gdbarch.h 17 Dec 2005 22:34:00 -0000 1.284
> +++ gdbarch.h 17 Apr 2006 19:03:21 -0000
> @@ -49,6 +49,7 @@ struct regset;
> struct disassemble_info;
> struct target_ops;
> struct obstack;
> +struct bp_target_info;
>
> extern struct gdbarch *current_gdbarch;
>
> @@ -899,24 +900,24 @@ typedef CORE_ADDR (gdbarch_adjust_breakp
> extern CORE_ADDR gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr);
> extern void set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address);
>
> -typedef int (gdbarch_memory_insert_breakpoint_ftype) (CORE_ADDR addr, gdb_byte *contents_cache);
> -extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, gdb_byte *contents_cache);
> +typedef int (gdbarch_memory_insert_breakpoint_ftype) (struct bp_target_info *bp_tgt);
> +extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
> extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
> #if !defined (GDB_TM_FILE) && defined (MEMORY_INSERT_BREAKPOINT)
> #error "Non multi-arch definition of MEMORY_INSERT_BREAKPOINT"
> #endif
> #if !defined (MEMORY_INSERT_BREAKPOINT)
> -#define MEMORY_INSERT_BREAKPOINT(addr, contents_cache) (gdbarch_memory_insert_breakpoint (current_gdbarch, addr, contents_cache))
> +#define MEMORY_INSERT_BREAKPOINT(bp_tgt) (gdbarch_memory_insert_breakpoint (current_gdbarch, bp_tgt))
> #endif
>
> -typedef int (gdbarch_memory_remove_breakpoint_ftype) (CORE_ADDR addr, gdb_byte *contents_cache);
> -extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, gdb_byte *contents_cache);
> +typedef int (gdbarch_memory_remove_breakpoint_ftype) (struct bp_target_info *bp_tgt);
> +extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt);
> extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
> #if !defined (GDB_TM_FILE) && defined (MEMORY_REMOVE_BREAKPOINT)
> #error "Non multi-arch definition of MEMORY_REMOVE_BREAKPOINT"
> #endif
> #if !defined (MEMORY_REMOVE_BREAKPOINT)
> -#define MEMORY_REMOVE_BREAKPOINT(addr, contents_cache) (gdbarch_memory_remove_breakpoint (current_gdbarch, addr, contents_cache))
> +#define MEMORY_REMOVE_BREAKPOINT(bp_tgt) (gdbarch_memory_remove_breakpoint (current_gdbarch, bp_tgt))
> #endif
>
> extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
> Index: gdbarch.sh
> ===================================================================
> RCS file: /cvs/src/src/gdb/gdbarch.sh,v
> retrieving revision 1.363
> diff -u -p -r1.363 gdbarch.sh
> --- gdbarch.sh 17 Dec 2005 22:34:00 -0000 1.363
> +++ gdbarch.sh 17 Apr 2006 19:03:22 -0000
> @@ -549,8 +549,8 @@ f:=:CORE_ADDR:skip_prologue:CORE_ADDR ip
> f:=:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0
> f:=:const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:
> M::CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr
> -f:=:int:memory_insert_breakpoint:CORE_ADDR addr, gdb_byte *contents_cache:addr, contents_cache:0:default_memory_insert_breakpoint::0
> -f:=:int:memory_remove_breakpoint:CORE_ADDR addr, gdb_byte *contents_cache:addr, contents_cache:0:default_memory_remove_breakpoint::0
> +f:=:int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0
> +f:=:int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0
> v:=:CORE_ADDR:decr_pc_after_break:::0:::0
>
> # A function can be addressed by either it's "pointer" (possibly a
> @@ -771,6 +771,7 @@ struct regset;
> struct disassemble_info;
> struct target_ops;
> struct obstack;
> +struct bp_target_info;
>
> extern struct gdbarch *current_gdbarch;
> EOF
> Index: i386-nat.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/i386-nat.c,v
> retrieving revision 1.13
> diff -u -p -r1.13 i386-nat.c
> --- i386-nat.c 17 Dec 2005 22:34:01 -0000 1.13
> +++ i386-nat.c 17 Apr 2006 19:03:22 -0000
> @@ -625,12 +625,13 @@ i386_stopped_by_hwbp (void)
> return 0;
> }
>
> -/* Insert a hardware-assisted breakpoint at address ADDR. SHADOW is
> - unused. Return 0 on success, EBUSY on failure. */
> +/* Insert a hardware-assisted breakpoint at BP_TGT->placed_address.
> + Return 0 on success, EBUSY on failure. */
> int
> -i386_insert_hw_breakpoint (CORE_ADDR addr, void *shadow)
> +i386_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
> + CORE_ADDR addr = bp_tgt->placed_address;
> int retval = i386_insert_aligned_watchpoint (addr, len_rw) ? EBUSY : 0;
>
> if (maint_show_dr)
> @@ -639,13 +640,14 @@ i386_insert_hw_breakpoint (CORE_ADDR add
> return retval;
> }
>
> -/* Remove a hardware-assisted breakpoint at address ADDR. SHADOW is
> - unused. Return 0 on success, -1 on failure. */
> +/* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
> + Return 0 on success, -1 on failure. */
>
> int
> -i386_remove_hw_breakpoint (CORE_ADDR addr, void *shadow)
> +i386_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
> + CORE_ADDR addr = bp_tgt->placed_address;
> int retval = i386_remove_aligned_watchpoint (addr, len_rw);
>
> if (maint_show_dr)
> Index: ia64-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/ia64-tdep.c,v
> retrieving revision 1.138
> diff -u -p -r1.138 ia64-tdep.c
> --- ia64-tdep.c 8 Mar 2006 15:28:17 -0000 1.138
> +++ ia64-tdep.c 17 Apr 2006 19:03:22 -0000
> @@ -550,8 +550,9 @@ fetch_instruction (CORE_ADDR addr, instr
> #define IA64_BREAKPOINT 0x00003333300LL
>
> static int
> -ia64_memory_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +ia64_memory_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> char bundle[BUNDLE_LEN];
> int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
> long long instr;
> @@ -574,7 +575,8 @@ ia64_memory_insert_breakpoint (CORE_ADDR
> }
>
> instr = slotN_contents (bundle, slotnum);
> - memcpy(contents_cache, &instr, sizeof(instr));
> + memcpy (bp_tgt->shadow_contents, &instr, sizeof (instr));
> + bp_tgt->placed_size = bp_tgt->shadow_len = sizeof (instr);
> replace_slotN_contents (bundle, IA64_BREAKPOINT, slotnum);
> if (val == 0)
> target_write_memory (addr, bundle, BUNDLE_LEN);
> @@ -583,8 +585,9 @@ ia64_memory_insert_breakpoint (CORE_ADDR
> }
>
> static int
> -ia64_memory_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +ia64_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> char bundle[BUNDLE_LEN];
> int slotnum = (addr & 0x0f) / SLOT_MULTIPLIER;
> long long instr;
> @@ -603,7 +606,7 @@ ia64_memory_remove_breakpoint (CORE_ADDR
> slotnum = 2;
> }
>
> - memcpy (&instr, contents_cache, sizeof instr);
> + memcpy (&instr, bp_tgt->shadow_contents, sizeof instr);
> replace_slotN_contents (bundle, instr, slotnum);
> if (val == 0)
> target_write_memory (addr, bundle, BUNDLE_LEN);
> Index: m32r-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/m32r-tdep.c,v
> retrieving revision 1.40
> diff -u -p -r1.40 m32r-tdep.c
> --- m32r-tdep.c 17 Dec 2005 22:34:01 -0000 1.40
> +++ m32r-tdep.c 17 Apr 2006 19:03:22 -0000
> @@ -81,10 +81,12 @@ m32r_frame_align (struct gdbarch *gdbarc
> The following functions take care of this behavior. */
>
> static int
> -m32r_memory_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +m32r_memory_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int val;
> gdb_byte buf[4];
> + gdb_byte *contents_cache = bp_tgt->shadow_contents;
> gdb_byte bp_entry[] = { 0x10, 0xf1 }; /* dpt */
>
> /* Save the memory contents. */
> @@ -92,6 +94,8 @@ m32r_memory_insert_breakpoint (CORE_ADDR
> if (val != 0)
> return val; /* return error */
>
> + bp_tgt->placed_size = bp_tgt->shadow_len = 4;
> +
> /* Determine appropriate breakpoint contents and size for this address. */
> if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
> {
> @@ -134,10 +138,12 @@ m32r_memory_insert_breakpoint (CORE_ADDR
> }
>
> static int
> -m32r_memory_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +m32r_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int val;
> gdb_byte buf[4];
> + gdb_byte *contents_cache = bp_tgt->shadow_contents;
>
> buf[0] = contents_cache[0];
> buf[1] = contents_cache[1];
> Index: mem-break.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/mem-break.c,v
> retrieving revision 1.11
> diff -u -p -r1.11 mem-break.c
> --- mem-break.c 17 Dec 2005 22:34:01 -0000 1.11
> +++ mem-break.c 17 Apr 2006 19:03:22 -0000
> @@ -33,60 +33,57 @@
> #include "target.h"
>
>
> -/* Insert a breakpoint on targets that don't have any better breakpoint
> - support. We read the contents of the target location and stash it,
> - then overwrite it with a breakpoint instruction. ADDR is the target
> - location in the target machine. CONTENTS_CACHE is a pointer to
> - memory allocated for saving the target contents. It is guaranteed
> - by the caller to be long enough to save BREAKPOINT_LEN bytes (this
> - is accomplished via BREAKPOINT_MAX). */
> +/* Insert a breakpoint on targets that don't have any better
> + breakpoint support. We read the contents of the target location
> + and stash it, then overwrite it with a breakpoint instruction.
> + BP_TGT->placed_address is the target location in the target
> + machine. BP_TGT->shadow_contents is some memory allocated for
> + saving the target contents. It is guaranteed by the caller to be
> + long enough to save BREAKPOINT_LEN bytes (this is accomplished via
> + BREAKPOINT_MAX). */
>
> int
> -default_memory_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +default_memory_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> int val;
> const unsigned char *bp;
> int bplen;
>
> /* Determine appropriate breakpoint contents and size for this address. */
> - bp = BREAKPOINT_FROM_PC (&addr, &bplen);
> + bp = BREAKPOINT_FROM_PC (&bp_tgt->placed_address, &bp_tgt->placed_size);
> if (bp == NULL)
> error (_("Software breakpoints not implemented for this target."));
>
> /* Save the memory contents. */
> - val = target_read_memory (addr, contents_cache, bplen);
> + bp_tgt->shadow_len = bp_tgt->placed_size;
> + val = target_read_memory (bp_tgt->placed_address, bp_tgt->shadow_contents,
> + bp_tgt->placed_size);
>
> /* Write the breakpoint. */
> if (val == 0)
> - val = target_write_memory (addr, bp, bplen);
> + val = target_write_memory (bp_tgt->placed_address, bp,
> + bp_tgt->placed_size);
>
> return val;
> }
>
>
> int
> -default_memory_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +default_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> - const bfd_byte *bp;
> - int bplen;
> -
> - /* Determine appropriate breakpoint contents and size for this address. */
> - bp = BREAKPOINT_FROM_PC (&addr, &bplen);
> - if (bp == NULL)
> - error (_("Software breakpoints not implemented for this target."));
> -
> - return target_write_memory (addr, contents_cache, bplen);
> + return target_write_memory (bp_tgt->placed_address, bp_tgt->shadow_contents,
> + bp_tgt->placed_size);
> }
>
>
> int
> -memory_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +memory_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> - return MEMORY_INSERT_BREAKPOINT(addr, contents_cache);
> + return MEMORY_INSERT_BREAKPOINT (bp_tgt);
> }
>
> int
> -memory_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +memory_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> - return MEMORY_REMOVE_BREAKPOINT(addr, contents_cache);
> + return MEMORY_REMOVE_BREAKPOINT (bp_tgt);
> }
> Index: mips-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/mips-tdep.c,v
> retrieving revision 1.388
> diff -u -p -r1.388 mips-tdep.c
> --- mips-tdep.c 15 Mar 2006 16:59:54 -0000 1.388
> +++ mips-tdep.c 17 Apr 2006 19:03:23 -0000
> @@ -2188,20 +2188,17 @@ mips_addr_bits_remove (CORE_ADDR addr)
> void
> mips_software_single_step (enum target_signal sig, int insert_breakpoints_p)
> {
> - static CORE_ADDR next_pc;
> - typedef char binsn_quantum[BREAKPOINT_MAX];
> - static binsn_quantum break_mem;
> - CORE_ADDR pc;
> + CORE_ADDR pc, next_pc;
>
> if (insert_breakpoints_p)
> {
> pc = read_register (mips_regnum (current_gdbarch)->pc);
> next_pc = mips_next_pc (pc);
>
> - target_insert_breakpoint (next_pc, break_mem);
> + insert_single_step_breakpoint (next_pc);
> }
> else
> - target_remove_breakpoint (next_pc, break_mem);
> + remove_single_step_breakpoints ();
> }
>
> /* Test whether the PC points to the return instruction at the
> Index: monitor.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/monitor.c,v
> retrieving revision 1.63
> diff -u -p -r1.63 monitor.c
> --- monitor.c 24 Jan 2006 22:09:28 -0000 1.63
> +++ monitor.c 17 Apr 2006 19:03:23 -0000
> @@ -85,8 +85,6 @@ static int monitor_xfer_memory (CORE_ADD
> struct mem_attrib *attrib,
> struct target_ops *target);
> static void monitor_files_info (struct target_ops *ops);
> -static int monitor_insert_breakpoint (CORE_ADDR addr, gdb_byte *shadow);
> -static int monitor_remove_breakpoint (CORE_ADDR addr, gdb_byte *shadow);
> static void monitor_kill (void);
> static void monitor_load (char *file, int from_tty);
> static void monitor_mourn_inferior (void);
> @@ -2037,8 +2035,9 @@ monitor_mourn_inferior (void)
> /* Tell the monitor to add a breakpoint. */
>
> static int
> -monitor_insert_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
> +monitor_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i;
> const unsigned char *bp;
> int bplen;
> @@ -2052,13 +2051,14 @@ monitor_insert_breakpoint (CORE_ADDR add
>
> /* Determine appropriate breakpoint size for this address. */
> bp = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen);
> + bp_tgt->placed_address = addr;
> + bp_tgt->placed_size = bplen;
>
> for (i = 0; i < current_monitor->num_breakpoints; i++)
> {
> if (breakaddr[i] == 0)
> {
> breakaddr[i] = addr;
> - monitor_read_memory (addr, shadow, bplen);
> monitor_printf (current_monitor->set_break, addr);
> monitor_expect_prompt (NULL, 0);
> return 0;
> @@ -2071,17 +2071,15 @@ monitor_insert_breakpoint (CORE_ADDR add
> /* Tell the monitor to remove a breakpoint. */
>
> static int
> -monitor_remove_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
> +monitor_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i;
>
> monitor_debug ("MON rmbkpt %s\n", paddr (addr));
> if (current_monitor->clr_break == NULL)
> error (_("No clr_break defined for this monitor"));
>
> - if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
> - addr = ADDR_BITS_REMOVE (addr);
> -
> for (i = 0; i < current_monitor->num_breakpoints; i++)
> {
> if (breakaddr[i] == addr)
> Index: nto-procfs.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/nto-procfs.c,v
> retrieving revision 1.17
> diff -u -p -r1.17 nto-procfs.c
> --- nto-procfs.c 24 Jan 2006 22:09:28 -0000 1.17
> +++ nto-procfs.c 17 Apr 2006 19:03:23 -0000
> @@ -76,10 +76,6 @@ static ptid_t do_attach (ptid_t ptid);
>
> static int procfs_can_use_hw_breakpoint (int, int, int);
>
> -static int procfs_insert_hw_breakpoint (CORE_ADDR, char *);
> -
> -static int procfs_remove_hw_breakpoint (CORE_ADDR addr, char *);
> -
> static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type);
>
> static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type);
> @@ -812,27 +808,29 @@ procfs_breakpoint (CORE_ADDR addr, int t
> }
>
> static int
> -procfs_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
> +procfs_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> - return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC, 0);
> + return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
> }
>
> static int
> -procfs_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
> +procfs_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> - return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC, -1);
> + return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
> }
>
> static int
> -procfs_insert_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
> +procfs_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> - return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
> + return procfs_breakpoint (bp_tgt->placed_address,
> + _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
> }
>
> static int
> -procfs_remove_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
> +procfs_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> - return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
> + return procfs_breakpoint (bp_tgt->placed_address,
> + _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
> }
>
> static void
> Index: ocd.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/ocd.c,v
> retrieving revision 1.43
> diff -u -p -r1.43 ocd.c
> --- ocd.c 24 Jan 2006 22:09:28 -0000 1.43
> +++ ocd.c 17 Apr 2006 19:03:23 -0000
> @@ -1048,28 +1048,27 @@ ocd_load (char *args, int from_tty)
> /* BDM (at least on CPU32) uses a different breakpoint */
>
> int
> -ocd_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
> +ocd_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> static char break_insn[] = BDM_BREAKPOINT;
> int val;
>
> - val = target_read_memory (addr, contents_cache, sizeof (break_insn));
> + bp_tgt->placed_size = bp_tgt->shadow_len = sizeof (break_insn);
> + val = target_read_memory (bp_tgt->placed_address, bp_tgt->shadow_contents,
> + bp_tgt->placed_size);
>
> if (val == 0)
> - val = target_write_memory (addr, break_insn, sizeof (break_insn));
> + val = target_write_memory (bp_tgt->placed_address, break_insn,
> + bp_tgt->placed_size);
>
> return val;
> }
>
> int
> -ocd_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
> +ocd_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> - static char break_insn[] = BDM_BREAKPOINT;
> - int val;
> -
> - val = target_write_memory (addr, contents_cache, sizeof (break_insn));
> -
> - return val;
> + return target_write_memory (bp_tgt->placed_address, bp_tgt->shadow_contents,
> + bp_tgt->placed_size);
> }
>
> static void
> Index: ocd.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/ocd.h,v
> retrieving revision 1.8
> diff -u -p -r1.8 ocd.h
> --- ocd.h 17 Dec 2005 22:34:01 -0000 1.8
> +++ ocd.h 17 Apr 2006 19:03:23 -0000
> @@ -135,8 +135,8 @@ void ocd_write_bdm_register (int bdm_reg
>
> int ocd_wait (void);
>
> -int ocd_insert_breakpoint (CORE_ADDR addr, char *contents_cache);
> -int ocd_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
> +int ocd_insert_breakpoint (struct bp_target_info *bp_tgt);
> +int ocd_remove_breakpoint (struct bp_target_info *bp_tgt);
>
> int ocd_write_bytes (CORE_ADDR memaddr, char *myaddr, int len);
>
> Index: ppc-linux-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
> retrieving revision 1.77
> diff -u -p -r1.77 ppc-linux-tdep.c
> --- ppc-linux-tdep.c 15 Jan 2006 18:28:58 -0000 1.77
> +++ ppc-linux-tdep.c 17 Apr 2006 19:03:23 -0000
> @@ -457,9 +457,9 @@ ppc_linux_skip_trampoline_code (CORE_ADD
> regard to removing breakpoints in some potentially self modifying
> code. */
> int
> -ppc_linux_memory_remove_breakpoint (CORE_ADDR addr,
> - gdb_byte *contents_cache)
> +ppc_linux_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> const unsigned char *bp;
> int val;
> int bplen;
> @@ -476,7 +476,7 @@ ppc_linux_memory_remove_breakpoint (CORE
> program modified the code on us, so it is wrong to put back the
> old value */
> if (val == 0 && memcmp (bp, old_contents, bplen) == 0)
> - val = target_write_memory (addr, contents_cache, bplen);
> + val = target_write_memory (addr, bp_tgt->shadow_contents, bplen);
>
> return val;
> }
> Index: ppc-tdep.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
> retrieving revision 1.50
> diff -u -p -r1.50 ppc-tdep.h
> --- ppc-tdep.h 17 Jan 2006 22:21:13 -0000 1.50
> +++ ppc-tdep.h 17 Apr 2006 19:03:24 -0000
> @@ -56,8 +56,7 @@ CORE_ADDR ppc64_sysv_abi_push_dummy_call
> CORE_ADDR struct_addr);
> CORE_ADDR ppc64_sysv_abi_adjust_breakpoint_address (struct gdbarch *gdbarch,
> CORE_ADDR bpaddr);
> -int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr,
> - gdb_byte *contents_cache);
> +int ppc_linux_memory_remove_breakpoint (struct bp_target_info *bp_tgt);
> struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
> void ppc_linux_supply_gregset (struct regcache *regcache,
> int regnum, const void *gregs, size_t size,
> Index: procfs.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/procfs.c,v
> retrieving revision 1.68
> diff -u -p -r1.68 procfs.c
> --- procfs.c 24 Jan 2006 22:09:28 -0000 1.68
> +++ procfs.c 17 Apr 2006 19:03:25 -0000
> @@ -3375,7 +3375,7 @@ static void remove_dbx_link_breakpoint (
> the address of the breakpoint, and the code that was replaced by
> a breakpoint. */
> static int dbx_link_bpt_addr = 0;
> -static char dbx_link_shadow_contents[BREAKPOINT_MAX];
> +static void *dbx_link_bpt;
>
> /*
> * Function: procfs_debug_inferior
> @@ -4777,6 +4777,14 @@ procfs_mourn_inferior (void)
> destroy_procinfo (pi);
> }
> unpush_target (&procfs_ops);
> +
> + if (dbx_link_bpt != NULL)
> + {
> + deprecated_remove_raw_breakpoint (dbx_link_bpt);
> + dbx_link_bpt_addr = 0;
> + dbx_link_bpt = NULL;
> + }
> +
> generic_mourn_inferior ();
> }
>
> @@ -4886,7 +4894,6 @@ procfs_init_inferior (int pid)
> has been inserted, the syssgi() notifications are no longer necessary,
> so they should be canceled. */
> proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT, FLAG_SET, 0);
> - dbx_link_bpt_addr = 0;
> #endif
> }
>
> @@ -5571,11 +5578,11 @@ remove_dbx_link_breakpoint (void)
> if (dbx_link_bpt_addr == 0)
> return;
>
> - if (memory_remove_breakpoint (dbx_link_bpt_addr,
> - dbx_link_shadow_contents) != 0)
> + if (deprecated_remove_raw_breakpoint (dbx_link_bpt) != 0)
> warning (_("Unable to remove __dbx_link breakpoint."));
>
> dbx_link_bpt_addr = 0;
> + dbx_link_bpt = NULL;
> }
>
> /* Return the address of the __dbx_link() function in the file
> @@ -5643,7 +5650,8 @@ insert_dbx_link_bpt_in_file (int fd, COR
> {
> /* Insert the breakpoint. */
> dbx_link_bpt_addr = sym_addr;
> - if (target_insert_breakpoint (sym_addr, dbx_link_shadow_contents) != 0)
> + dbx_link_bpt = deprecated_insert_raw_breakpoint (sym_addr);
> + if (dbx_link_bpt == NULL)
> {
> warning (_("Failed to insert dbx_link breakpoint."));
> bfd_close (abfd);
> Index: remote-e7000.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote-e7000.c,v
> retrieving revision 1.57
> diff -u -p -r1.57 remote-e7000.c
> --- remote-e7000.c 24 Jan 2006 22:09:28 -0000 1.57
> +++ remote-e7000.c 17 Apr 2006 19:03:25 -0000
> @@ -1702,8 +1702,9 @@ static CORE_ADDR breakaddr[MAX_BREAKPOIN
> {0};
>
> static int
> -e7000_insert_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
> +e7000_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i;
> char buf[200];
> #if 0
> @@ -1728,7 +1729,8 @@ e7000_insert_breakpoint (CORE_ADDR addr,
> }
> #else
> #if 0
> - e7000_read_inferior_memory (addr, shadow, 2);
> + bp_tgt->shadow_len = 2;
> + e7000_read_inferior_memory (addr, bp_tgt->shadow_contents, 2);
> e7000_write_inferior_memory (addr, nop, 2);
> #endif
>
> @@ -1745,8 +1747,9 @@ e7000_insert_breakpoint (CORE_ADDR addr,
> }
>
> static int
> -e7000_remove_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
> +e7000_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i;
> char buf[200];
>
> @@ -1773,7 +1776,8 @@ e7000_remove_breakpoint (CORE_ADDR addr,
>
> #if 0
> /* Replace the insn under the break */
> - e7000_write_inferior_memory (addr, shadow, 2);
> + e7000_write_inferior_memory (addr, bp_tgt->shadow_contents,
> + bp_tgt->shadow_len);
> #endif
> #endif
>
> Index: remote-m32r-sdi.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote-m32r-sdi.c,v
> retrieving revision 1.17
> diff -u -p -r1.17 remote-m32r-sdi.c
> --- remote-m32r-sdi.c 24 Jan 2006 22:09:28 -0000 1.17
> +++ remote-m32r-sdi.c 17 Apr 2006 19:03:25 -0000
> @@ -1141,15 +1141,16 @@ m32r_mourn_inferior (void)
> }
>
> static int
> -m32r_insert_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
> +m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int ib_breakpoints;
> unsigned char buf[13];
> int i, c;
>
> if (remote_debug)
> - fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%08lx,\"%s\")\n",
> - addr, shadow);
> + fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%08lx,...)\n",
> + addr);
>
> if (use_ib_breakpoints)
> ib_breakpoints = max_ib_breakpoints;
> @@ -1183,13 +1184,14 @@ m32r_insert_breakpoint (CORE_ADDR addr,
> }
>
> static int
> -m32r_remove_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
> +m32r_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i;
>
> if (remote_debug)
> - fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%08lx,\"%s\")\n",
> - addr, shadow);
> + fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%08lx)\n",
> + addr);
>
> for (i = 0; i < MAX_BREAKPOINTS; i++)
> {
> Index: remote-mips.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote-mips.c,v
> retrieving revision 1.68
> diff -u -p -r1.68 remote-mips.c
> --- remote-mips.c 24 Jan 2006 22:09:28 -0000 1.68
> +++ remote-mips.c 17 Apr 2006 19:03:26 -0000
> @@ -2216,27 +2216,28 @@ mips_mourn_inferior (void)
> /* Insert a breakpoint. On targets that don't have built-in
> breakpoint support, we read the contents of the target location and
> stash it, then overwrite it with a breakpoint instruction. ADDR is
> - the target location in the target machine. CONTENTS_CACHE is a
> - pointer to memory allocated for saving the target contents. It is
> - guaranteed by the caller to be long enough to save the breakpoint
> - length returned by BREAKPOINT_FROM_PC. */
> + the target location in the target machine. BPT is the breakpoint
> + being inserted or removed, which contains memory for saving the
> + target contents. */
>
> static int
> -mips_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
> +mips_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> if (monitor_supports_breakpoints)
> - return set_breakpoint (addr, MIPS_INSN32_SIZE, BREAK_FETCH);
> + return set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
> + BREAK_FETCH);
> else
> - return memory_insert_breakpoint (addr, contents_cache);
> + return memory_insert_breakpoint (bp_tgt);
> }
>
> static int
> -mips_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
> +mips_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> if (monitor_supports_breakpoints)
> - return clear_breakpoint (addr, MIPS_INSN32_SIZE, BREAK_FETCH);
> + return clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
> + BREAK_FETCH);
> else
> - return memory_remove_breakpoint (addr, contents_cache);
> + return memory_remove_breakpoint (bp_tgt);
> }
>
> /* Tell whether this target can support a hardware breakpoint. CNT
> Index: remote-rdp.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote-rdp.c,v
> retrieving revision 1.49
> diff -u -p -r1.49 remote-rdp.c
> --- remote-rdp.c 3 Mar 2006 23:08:12 -0000 1.49
> +++ remote-rdp.c 17 Apr 2006 19:03:26 -0000
> @@ -1050,8 +1050,10 @@ rdp_execute (void)
> }
>
> static int
> -remote_rdp_insert_breakpoint (CORE_ADDR addr, bfd_byte *save)
> +remote_rdp_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> +
> int res;
> if (ds.rdi_level > 0)
> {
> @@ -1059,7 +1061,7 @@ remote_rdp_insert_breakpoint (CORE_ADDR
> RDP_SET_BREAK,
> addr,
> RDP_SET_BREAK_TYPE_PC_EQUAL | RDP_SET_BREAK_TYPE_GET_HANDLE,
> - save,
> + bp_tgt->shadow_contents,
> &res);
> }
> else
> @@ -1074,14 +1076,15 @@ remote_rdp_insert_breakpoint (CORE_ADDR
> }
>
> static int
> -remote_rdp_remove_breakpoint (CORE_ADDR addr, bfd_byte *save)
> +remote_rdp_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int res;
> if (ds.rdi_level > 0)
> {
> send_rdp ("b-p-S-B",
> RDP_CLEAR_BREAK,
> - save, 4,
> + bp_tgt->shadow_contents, 4,
> &res);
> }
> else
> @@ -1108,12 +1111,12 @@ rdp_step (void)
> }
> else
> {
> - char handle[4];
> + void *b;
> CORE_ADDR pc = read_register (ARM_PC_REGNUM);
> pc = arm_get_next_pc (pc);
> - remote_rdp_insert_breakpoint (pc, handle);
> + b = deprecated_insert_raw_breakpoint (pc);
> rdp_execute ();
> - remote_rdp_remove_breakpoint (pc, handle);
> + deprecated_remove_raw_breakpoint (b);
> }
> }
>
> Index: remote-sds.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote-sds.c,v
> retrieving revision 1.42
> diff -u -p -r1.42 remote-sds.c
> --- remote-sds.c 24 Jan 2006 22:09:28 -0000 1.42
> +++ remote-sds.c 17 Apr 2006 19:03:26 -0000
> @@ -99,10 +99,6 @@ static void interrupt_query (void);
>
> static int read_frame (char *);
>
> -static int sds_insert_breakpoint (CORE_ADDR, char *);
> -
> -static int sds_remove_breakpoint (CORE_ADDR, char *);
> -
> static void init_sds_ops (void);
>
> static void sds_command (char *args, int from_tty);
> @@ -1004,8 +1000,9 @@ sds_load (char *filename, int from_tty)
> replaced instruction back to the debugger. */
>
> static int
> -sds_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
> +sds_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i, retlen;
> unsigned char *p, buf[PBUFSIZ];
>
> @@ -1020,14 +1017,15 @@ sds_insert_breakpoint (CORE_ADDR addr, c
> retlen = sds_send (buf, p - buf);
>
> for (i = 0; i < 4; ++i)
> - contents_cache[i] = buf[i + 2];
> + bp_tgt->shadow_contents[i] = buf[i + 2];
>
> return 0;
> }
>
> static int
> -sds_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
> +sds_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i, retlen;
> unsigned char *p, buf[PBUFSIZ];
>
> @@ -1039,7 +1037,7 @@ sds_remove_breakpoint (CORE_ADDR addr, c
> *p++ = (int) (addr >> 8) & 0xff;
> *p++ = (int) (addr) & 0xff;
> for (i = 0; i < 4; ++i)
> - *p++ = contents_cache[i];
> + *p++ = bp_tgt->shadow_contents[i];
>
> retlen = sds_send (buf, p - buf);
>
> Index: remote-sim.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote-sim.c,v
> retrieving revision 1.53
> diff -u -p -r1.53 remote-sim.c
> --- remote-sim.c 21 Feb 2006 18:22:26 -0000 1.53
> +++ remote-sim.c 17 Apr 2006 19:03:26 -0000
> @@ -805,18 +805,6 @@ gdbsim_mourn_inferior (void)
> generic_mourn_inferior ();
> }
>
> -static int
> -gdbsim_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> -{
> - return memory_insert_breakpoint (addr, contents_cache);
> -}
> -
> -static int
> -gdbsim_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> -{
> - return memory_remove_breakpoint (addr, contents_cache);
> -}
> -
> /* Pass the command argument through to the simulator verbatim. The
> simulator must do any command interpretation work. */
>
> @@ -866,8 +854,8 @@ init_gdbsim_ops (void)
> gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
> gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
> gdbsim_ops.to_files_info = gdbsim_files_info;
> - gdbsim_ops.to_insert_breakpoint = gdbsim_insert_breakpoint;
> - gdbsim_ops.to_remove_breakpoint = gdbsim_remove_breakpoint;
> + gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
> + gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
> gdbsim_ops.to_kill = gdbsim_kill;
> gdbsim_ops.to_load = gdbsim_load;
> gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
> Index: remote-st.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote-st.c,v
> retrieving revision 1.30
> diff -u -p -r1.30 remote-st.c
> --- remote-st.c 10 Feb 2006 22:01:43 -0000 1.30
> +++ remote-st.c 17 Apr 2006 19:03:26 -0000
> @@ -599,20 +599,16 @@ static CORE_ADDR breakaddr[MAX_STDEBUG_B
> {0};
>
> static int
> -st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
> +st2000_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i;
> - CORE_ADDR bp_addr = addr;
> - int bp_size = 0;
> -
> - BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
>
> for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
> if (breakaddr[i] == 0)
> {
> breakaddr[i] = addr;
>
> - st2000_read_inferior_memory (bp_addr, shadow, bp_size);
> printf_stdebug ("BR %x H\r", addr);
> expect_prompt (1);
> return 0;
> @@ -623,8 +619,9 @@ st2000_insert_breakpoint (CORE_ADDR addr
> }
>
> static int
> -st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
> +st2000_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> int i;
>
> for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
> Index: remote.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/remote.c,v
> retrieving revision 1.207
> diff -u -p -r1.207 remote.c
> --- remote.c 12 Apr 2006 14:27:40 -0000 1.207
> +++ remote.c 17 Apr 2006 19:03:27 -0000
> @@ -136,10 +136,6 @@ static void skip_frame (void);
>
> static long read_frame (char **buf_p, long *sizeof_buf);
>
> -static int remote_insert_breakpoint (CORE_ADDR, bfd_byte *);
> -
> -static int remote_remove_breakpoint (CORE_ADDR, bfd_byte *);
> -
> static int hexnumlen (ULONGEST num);
>
> static void init_remote_ops (void);
> @@ -4356,22 +4352,18 @@ static unsigned char little_break_insn[]
>
> #endif /* DEPRECATED_REMOTE_BREAKPOINT */
>
> -/* Insert a breakpoint on targets that don't have any better
> - breakpoint support. We read the contents of the target location
> - and stash it, then overwrite it with a breakpoint instruction.
> - ADDR is the target location in the target machine. CONTENTS_CACHE
> - is a pointer to memory allocated for saving the target contents.
> - It is guaranteed by the caller to be long enough to save the number
> - of bytes returned by BREAKPOINT_FROM_PC. */
> +/* Insert a breakpoint. On targets that have software breakpoint
> + support, we ask the remote target to do the work; on targets
> + which don't, we insert a traditional memory breakpoint. */
>
> static int
> -remote_insert_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +remote_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> struct remote_state *rs = get_remote_state ();
> #ifdef DEPRECATED_REMOTE_BREAKPOINT
> int val;
> #endif
> - int bp_size;
>
> /* Try the "Z" s/w breakpoint packet if it is not already disabled.
> If it succeeds, then set the support to PACKET_ENABLE. If it
> @@ -4382,13 +4374,13 @@ remote_insert_breakpoint (CORE_ADDR addr
> {
> char *p = rs->buf;
>
> - addr = remote_address_masked (addr);
> *(p++) = 'Z';
> *(p++) = '0';
> *(p++) = ',';
> - p += hexnumstr (p, (ULONGEST) addr);
> - BREAKPOINT_FROM_PC (&addr, &bp_size);
> - sprintf (p, ",%d", bp_size);
> + BREAKPOINT_FROM_PC (&bp_tgt->placed_address, &bp_tgt->placed_size);
> + addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
> + p += hexnumstr (p, addr);
> + sprintf (p, ",%d", bp_tgt->placed_size);
>
> putpkt (rs->buf);
> getpkt (&rs->buf, &rs->buf_size, 0);
> @@ -4405,7 +4397,8 @@ remote_insert_breakpoint (CORE_ADDR addr
> }
>
> #ifdef DEPRECATED_REMOTE_BREAKPOINT
> - val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
> + bp_tgt->placed_size = bp_tgt->shadow_len = sizeof big_break_insn;
> + val = target_read_memory (addr, bp_tgt->shadow_contents, bp_tgt->shadow_len);
>
> if (val == 0)
> {
> @@ -4419,13 +4412,14 @@ remote_insert_breakpoint (CORE_ADDR addr
>
> return val;
> #else
> - return memory_insert_breakpoint (addr, contents_cache);
> + return memory_insert_breakpoint (bp_tgt);
> #endif /* DEPRECATED_REMOTE_BREAKPOINT */
> }
>
> static int
> -remote_remove_breakpoint (CORE_ADDR addr, bfd_byte *contents_cache)
> +remote_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> + CORE_ADDR addr = bp_tgt->placed_address;
> struct remote_state *rs = get_remote_state ();
> int bp_size;
>
> @@ -4437,10 +4431,9 @@ remote_remove_breakpoint (CORE_ADDR addr
> *(p++) = '0';
> *(p++) = ',';
>
> - addr = remote_address_masked (addr);
> - p += hexnumstr (p, (ULONGEST) addr);
> - BREAKPOINT_FROM_PC (&addr, &bp_size);
> - sprintf (p, ",%d", bp_size);
> + addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
> + p += hexnumstr (p, addr);
> + sprintf (p, ",%d", bp_tgt->placed_size);
>
> putpkt (rs->buf);
> getpkt (&rs->buf, &rs->buf_size, 0);
> @@ -4449,9 +4442,10 @@ remote_remove_breakpoint (CORE_ADDR addr
> }
>
> #ifdef DEPRECATED_REMOTE_BREAKPOINT
> - return target_write_memory (addr, contents_cache, sizeof big_break_insn);
> + return target_write_memory (bp_tgt->placed_address, bp_tgt->shadow_contents,
> + bp_tgt->shadow_len);
> #else
> - return memory_remove_breakpoint (addr, contents_cache);
> + return memory_remove_breakpoint (bp_tgt);
> #endif /* DEPRECATED_REMOTE_BREAKPOINT */
> }
>
> @@ -4595,16 +4589,16 @@ remote_stopped_data_address (struct targ
>
>
> static int
> -remote_insert_hw_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
> +remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> - int len = 0;
> + CORE_ADDR addr;
> struct remote_state *rs = get_remote_state ();
> char *p = rs->buf;
>
> /* The length field should be set to the size of a breakpoint
> - instruction. */
> + instruction, even though we aren't inserting one ourselves. */
>
> - BREAKPOINT_FROM_PC (&addr, &len);
> + BREAKPOINT_FROM_PC (&bp_tgt->placed_address, &bp_tgt->placed_size);
>
> if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
> error (_("Can't set hardware breakpoint without the '%s' (%s) packet."),
> @@ -4615,9 +4609,9 @@ remote_insert_hw_breakpoint (CORE_ADDR a
> *(p++) = '1';
> *(p++) = ',';
>
> - addr = remote_address_masked (addr);
> + addr = remote_address_masked (bp_tgt->placed_address);
> p += hexnumstr (p, (ULONGEST) addr);
> - sprintf (p, ",%x", len);
> + sprintf (p, ",%x", bp_tgt->placed_size);
>
> putpkt (rs->buf);
> getpkt (&rs->buf, &rs->buf_size, 0);
> @@ -4636,17 +4630,12 @@ remote_insert_hw_breakpoint (CORE_ADDR a
>
>
> static int
> -remote_remove_hw_breakpoint (CORE_ADDR addr, gdb_byte *shadow)
> +remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> - int len;
> + CORE_ADDR addr;
> struct remote_state *rs = get_remote_state ();
> char *p = rs->buf;
>
> - /* The length field should be set to the size of a breakpoint
> - instruction. */
> -
> - BREAKPOINT_FROM_PC (&addr, &len);
> -
> if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
> error (_("Can't clear hardware breakpoint without the '%s' (%s) packet."),
> remote_protocol_packets[PACKET_Z1].name,
> @@ -4656,9 +4645,9 @@ remote_remove_hw_breakpoint (CORE_ADDR a
> *(p++) = '1';
> *(p++) = ',';
>
> - addr = remote_address_masked (addr);
> + addr = remote_address_masked (bp_tgt->placed_address);
> p += hexnumstr (p, (ULONGEST) addr);
> - sprintf (p, ",%x", len);
> + sprintf (p, ",%x", bp_tgt->placed_size);
>
> putpkt (rs->buf);
> getpkt (&rs->buf, &rs->buf_size, 0);
> Index: rs6000-nat.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/rs6000-nat.c,v
> retrieving revision 1.60
> diff -u -p -r1.60 rs6000-nat.c
> --- rs6000-nat.c 17 Dec 2005 22:34:02 -0000 1.60
> +++ rs6000-nat.c 17 Apr 2006 19:03:27 -0000
> @@ -527,15 +527,15 @@ exec_one_dummy_insn (void)
> {
> #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
>
> - char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
> int ret, status, pid;
> CORE_ADDR prev_pc;
> + void *bp;
>
> /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
> assume that this address will never be executed again by the real
> code. */
>
> - target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
> + bp = deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR);
>
> /* You might think this could be done with a single ptrace call, and
> you'd be correct for just about every platform I've ever worked
> @@ -559,7 +559,7 @@ exec_one_dummy_insn (void)
> while (pid != PIDGET (inferior_ptid));
>
> write_pc (prev_pc);
> - target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
> + deprecated_remove_raw_breakpoint (bp);
> }
>
> /* Fetch registers from the register section in core bfd. */
> Index: rs6000-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v
> retrieving revision 1.256
> diff -u -p -r1.256 rs6000-tdep.c
> --- rs6000-tdep.c 10 Feb 2006 20:56:14 -0000 1.256
> +++ rs6000-tdep.c 17 Apr 2006 19:03:27 -0000
> @@ -110,17 +110,6 @@ struct reg
> register number. */
> };
>
> -/* Breakpoint shadows for the single step instructions will be kept here. */
> -
> -static struct sstep_breaks
> -{
> - /* Address, or 0 if this is not in use. */
> - CORE_ADDR address;
> - /* Shadow contents. */
> - gdb_byte data[4];
> -}
> -stepBreaks[2];
> -
> /* Hook for determining the TOC address when calling functions in the
> inferior under AIX. The initialization code in rs6000-nat.c sets
> this hook to point to find_toc_address. */
> @@ -730,7 +719,6 @@ rs6000_software_single_step (enum target
>
> if (insert_breakpoints_p)
> {
> -
> loc = read_pc ();
>
> insn = read_memory_integer (loc, 4);
> @@ -743,28 +731,17 @@ rs6000_software_single_step (enum target
> if (breaks[1] == breaks[0])
> breaks[1] = -1;
>
> - stepBreaks[1].address = 0;
> -
> for (ii = 0; ii < 2; ++ii)
> {
> -
> /* ignore invalid breakpoint. */
> if (breaks[ii] == -1)
> continue;
> - target_insert_breakpoint (breaks[ii], stepBreaks[ii].data);
> - stepBreaks[ii].address = breaks[ii];
> + insert_single_step_breakpoint (breaks[ii]);
> }
> -
> }
> else
> - {
> + remove_single_step_breakpoints ();
>
> - /* remove step breakpoints. */
> - for (ii = 0; ii < 2; ++ii)
> - if (stepBreaks[ii].address != 0)
> - target_remove_breakpoint (stepBreaks[ii].address,
> - stepBreaks[ii].data);
> - }
> errno = 0; /* FIXME, don't ignore errors! */
> /* What errors? {read,write}_memory call error(). */
> }
> Index: sol-thread.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/sol-thread.c,v
> retrieving revision 1.51
> diff -u -p -r1.51 sol-thread.c
> --- sol-thread.c 17 Dec 2005 22:34:02 -0000 1.51
> +++ sol-thread.c 17 Apr 2006 19:03:27 -0000
> @@ -1524,7 +1524,7 @@ sol_make_note_section (bfd *obfd, int *n
> }
>
> static int
> -ignore (CORE_ADDR addr, gdb_byte *contents)
> +ignore (struct bp_target_info *bp_tgt)
> {
> return 0;
> }
> Index: solib-irix.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/solib-irix.c,v
> retrieving revision 1.9
> diff -u -p -r1.9 solib-irix.c
> --- solib-irix.c 17 Dec 2005 22:34:02 -0000 1.9
> +++ solib-irix.c 17 Apr 2006 19:03:28 -0000
> @@ -227,10 +227,9 @@ fetch_lm_info (CORE_ADDR addr)
> /* The symbol which starts off the list of shared libraries. */
> #define DEBUG_BASE "__rld_obj_head"
>
> -char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
> +static void *base_breakpoint;
>
> static CORE_ADDR debug_base; /* Base of dynamic linker structures */
> -static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */
>
> /*
>
> @@ -319,11 +318,13 @@ disable_break (void)
> /* Note that breakpoint address and original contents are in our address
> space, so we just need to write the original contents back. */
>
> - if (memory_remove_breakpoint (breakpoint_addr, shadow_contents) != 0)
> + if (deprecated_remove_raw_breakpoint (base_breakpoint) != 0)
> {
> status = 0;
> }
>
> + base_breakpoint = NULL;
> +
> /* Note that it is possible that we have stopped at a location that
> is different from the location where we inserted our breakpoint.
> On mips-irix, we can actually land in __dbx_init(), so we should
> @@ -352,12 +353,13 @@ disable_break (void)
> static int
> enable_break (void)
> {
> - if (symfile_objfile != NULL
> - && target_insert_breakpoint (entry_point_address (),
> - shadow_contents) == 0)
> + if (symfile_objfile != NULL)
> {
> - breakpoint_addr = entry_point_address ();
> - return 1;
> + base_breakpoint
> + = deprecated_insert_raw_breakpoint (entry_point_address ());
> +
> + if (base_breakpoint != NULL)
> + return 1;
> }
>
> return 0;
> Index: sparc-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/sparc-tdep.c,v
> retrieving revision 1.171
> diff -u -p -r1.171 sparc-tdep.c
> --- sparc-tdep.c 9 Apr 2006 08:22:43 -0000 1.171
> +++ sparc-tdep.c 17 Apr 2006 19:03:28 -0000
> @@ -1136,8 +1136,7 @@ sparc_software_single_step (enum target_
> {
> struct gdbarch *arch = current_gdbarch;
> struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
> - static CORE_ADDR npc, nnpc;
> - static gdb_byte npc_save[4], nnpc_save[4];
> + CORE_ADDR npc, nnpc;
>
> if (insert_breakpoints_p)
> {
> @@ -1149,9 +1148,10 @@ sparc_software_single_step (enum target_
> /* Analyze the instruction at PC. */
> nnpc = sparc_analyze_control_transfer (arch, pc, &npc);
> if (npc != 0)
> - target_insert_breakpoint (npc, npc_save);
> + insert_single_step_breakpoint (npc);
> +
> if (nnpc != 0)
> - target_insert_breakpoint (nnpc, nnpc_save);
> + insert_single_step_breakpoint (nnpc);
>
> /* Assert that we have set at least one breakpoint, and that
> they're not set at the same spot - unless we're going
> @@ -1160,12 +1160,7 @@ sparc_software_single_step (enum target_
> gdb_assert (nnpc != npc || orig_npc == 0);
> }
> else
> - {
> - if (npc != 0)
> - target_remove_breakpoint (npc, npc_save);
> - if (nnpc != 0)
> - target_remove_breakpoint (nnpc, nnpc_save);
> - }
> + remove_single_step_breakpoints ();
> }
>
> static void
> Index: target.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/target.c,v
> retrieving revision 1.117
> diff -u -p -r1.117 target.c
> --- target.c 17 Mar 2006 00:30:34 -0000 1.117
> +++ target.c 17 Apr 2006 19:03:28 -0000
> @@ -111,15 +111,15 @@ static void debug_to_prepare_to_store (v
>
> static void debug_to_files_info (struct target_ops *);
>
> -static int debug_to_insert_breakpoint (CORE_ADDR, gdb_byte *);
> +static int debug_to_insert_breakpoint (struct bp_target_info *);
>
> -static int debug_to_remove_breakpoint (CORE_ADDR, gdb_byte *);
> +static int debug_to_remove_breakpoint (struct bp_target_info *);
>
> static int debug_to_can_use_hw_breakpoint (int, int, int);
>
> -static int debug_to_insert_hw_breakpoint (CORE_ADDR, gdb_byte *);
> +static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
>
> -static int debug_to_remove_hw_breakpoint (CORE_ADDR, gdb_byte *);
> +static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
>
> static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
>
> @@ -515,10 +515,10 @@ update_current_target (void)
> (int (*) (int, int, int))
> return_zero);
> de_fault (to_insert_hw_breakpoint,
> - (int (*) (CORE_ADDR, gdb_byte *))
> + (int (*) (struct bp_target_info *))
> return_minus_one);
> de_fault (to_remove_hw_breakpoint,
> - (int (*) (CORE_ADDR, gdb_byte *))
> + (int (*) (struct bp_target_info *))
> return_minus_one);
> de_fault (to_insert_watchpoint,
> (int (*) (CORE_ADDR, int, int))
> @@ -2075,29 +2075,29 @@ debug_to_files_info (struct target_ops *
> }
>
> static int
> -debug_to_insert_breakpoint (CORE_ADDR addr, gdb_byte *save)
> +debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
> {
> int retval;
>
> - retval = debug_target.to_insert_breakpoint (addr, save);
> + retval = debug_target.to_insert_breakpoint (bp_tgt);
>
> fprintf_unfiltered (gdb_stdlog,
> "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
> - (unsigned long) addr,
> + (unsigned long) bp_tgt->placed_address,
> (unsigned long) retval);
> return retval;
> }
>
> static int
> -debug_to_remove_breakpoint (CORE_ADDR addr, gdb_byte *save)
> +debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
> {
> int retval;
>
> - retval = debug_target.to_remove_breakpoint (addr, save);
> + retval = debug_target.to_remove_breakpoint (bp_tgt);
>
> fprintf_unfiltered (gdb_stdlog,
> "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
> - (unsigned long) addr,
> + (unsigned long) bp_tgt->placed_address,
> (unsigned long) retval);
> return retval;
> }
> @@ -2161,29 +2161,29 @@ debug_to_stopped_data_address (struct ta
> }
>
> static int
> -debug_to_insert_hw_breakpoint (CORE_ADDR addr, gdb_byte *save)
> +debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> int retval;
>
> - retval = debug_target.to_insert_hw_breakpoint (addr, save);
> + retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
>
> fprintf_unfiltered (gdb_stdlog,
> "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
> - (unsigned long) addr,
> + (unsigned long) bp_tgt->placed_address,
> (unsigned long) retval);
> return retval;
> }
>
> static int
> -debug_to_remove_hw_breakpoint (CORE_ADDR addr, gdb_byte *save)
> +debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
> {
> int retval;
>
> - retval = debug_target.to_remove_hw_breakpoint (addr, save);
> + retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
>
> fprintf_unfiltered (gdb_stdlog,
> "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
> - (unsigned long) addr,
> + (unsigned long) bp_tgt->placed_address,
> (unsigned long) retval);
> return retval;
> }
> Index: target.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/target.h,v
> retrieving revision 1.81
> diff -u -p -r1.81 target.h
> --- target.h 21 Feb 2006 18:22:26 -0000 1.81
> +++ target.h 17 Apr 2006 19:03:28 -0000
> @@ -30,6 +30,7 @@ struct objfile;
> struct ui_file;
> struct mem_attrib;
> struct target_ops;
> +struct bp_target_info;
>
> /* This include file defines the interface between the main part
> of the debugger, and the part which is target-specific, or
> @@ -336,11 +337,11 @@ struct target_ops
> struct target_ops *target);
>
> void (*to_files_info) (struct target_ops *);
> - int (*to_insert_breakpoint) (CORE_ADDR, gdb_byte *);
> - int (*to_remove_breakpoint) (CORE_ADDR, gdb_byte *);
> + int (*to_insert_breakpoint) (struct bp_target_info *);
> + int (*to_remove_breakpoint) (struct bp_target_info *);
> int (*to_can_use_hw_breakpoint) (int, int, int);
> - int (*to_insert_hw_breakpoint) (CORE_ADDR, gdb_byte *);
> - int (*to_remove_hw_breakpoint) (CORE_ADDR, gdb_byte *);
> + int (*to_insert_hw_breakpoint) (struct bp_target_info *);
> + int (*to_remove_hw_breakpoint) (struct bp_target_info *);
> int (*to_remove_watchpoint) (CORE_ADDR, int, int);
> int (*to_insert_watchpoint) (CORE_ADDR, int, int);
> int (*to_stopped_by_watchpoint) (void);
> @@ -612,22 +613,17 @@ extern void print_section_info (struct t
> #define target_files_info() \
> (*current_target.to_files_info) (¤t_target)
>
> -/* Insert a breakpoint at address ADDR in the target machine. SAVE is
> - a pointer to memory allocated for saving the target contents. It
> - is guaranteed by the caller to be long enough to save the number of
> - breakpoint bytes indicated by BREAKPOINT_FROM_PC. Result is 0 for
> - success, or an errno value. */
> -
> -#define target_insert_breakpoint(addr, save) \
> - (*current_target.to_insert_breakpoint) (addr, save)
> -
> -/* Remove a breakpoint at address ADDR in the target machine.
> - SAVE is a pointer to the same save area
> - that was previously passed to target_insert_breakpoint.
> - Result is 0 for success, or an errno value. */
> +/* Insert a breakpoint at address BP_TGT->placed_address in the target
> + machine. Result is 0 for success, or an errno value. */
>
> -#define target_remove_breakpoint(addr, save) \
> - (*current_target.to_remove_breakpoint) (addr, save)
> +#define target_insert_breakpoint(bp_tgt) \
> + (*current_target.to_insert_breakpoint) (bp_tgt)
> +
> +/* Remove a breakpoint at address BP_TGT->placed_address in the target
> + machine. Result is 0 for success, or an errno value. */
> +
> +#define target_remove_breakpoint(bp_tgt) \
> + (*current_target.to_remove_breakpoint) (bp_tgt)
>
> /* Initialize the terminal settings we record for the inferior,
> before we actually run the inferior. */
> @@ -1057,11 +1053,11 @@ extern void (*deprecated_target_new_objf
> #endif
>
> #ifndef target_insert_hw_breakpoint
> -#define target_insert_hw_breakpoint(addr, save) \
> - (*current_target.to_insert_hw_breakpoint) (addr, save)
> +#define target_insert_hw_breakpoint(bp_tgt) \
> + (*current_target.to_insert_hw_breakpoint) (bp_tgt)
>
> -#define target_remove_hw_breakpoint(addr, save) \
> - (*current_target.to_remove_hw_breakpoint) (addr, save)
> +#define target_remove_hw_breakpoint(bp_tgt) \
> + (*current_target.to_remove_hw_breakpoint) (bp_tgt)
> #endif
>
> extern int target_stopped_data_address_p (struct target_ops *);
> @@ -1142,13 +1138,13 @@ struct section_table *target_section_by_
>
> /* From mem-break.c */
>
> -extern int memory_remove_breakpoint (CORE_ADDR, gdb_byte *);
> +extern int memory_remove_breakpoint (struct bp_target_info *);
>
> -extern int memory_insert_breakpoint (CORE_ADDR, gdb_byte *);
> +extern int memory_insert_breakpoint (struct bp_target_info *);
>
> -extern int default_memory_remove_breakpoint (CORE_ADDR, gdb_byte *);
> +extern int default_memory_remove_breakpoint (struct bp_target_info *);
>
> -extern int default_memory_insert_breakpoint (CORE_ADDR, gdb_byte *);
> +extern int default_memory_insert_breakpoint (struct bp_target_info *);
>
>
> /* From target.c */
> Index: wince.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/wince.c,v
> retrieving revision 1.44
> diff -u -p -r1.44 wince.c
> --- wince.c 24 Jan 2006 22:09:28 -0000 1.44
> +++ wince.c 17 Apr 2006 19:03:28 -0000
> @@ -146,7 +146,6 @@ typedef struct thread_info_struct
> int suspend_count;
> int stepped; /* True if stepped. */
> CORE_ADDR step_pc;
> - unsigned long step_prev;
> CONTEXT context;
> }
> thread_info;
> @@ -834,7 +833,7 @@ undoSStep (thread_info * th)
> {
> if (th->stepped)
> {
> - memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
> + remove_single_step_breakpoints ();
> th->stepped = 0;
> }
> }
> @@ -857,8 +856,7 @@ wince_software_single_step (enum target_
> th->stepped = 1;
> pc = read_register (PC_REGNUM);
> th->step_pc = mips_next_pc (pc);
> - th->step_prev = 0;
> - memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
> + insert_single_step_breakpoint (th->step_pc);
> return;
> }
> #elif SHx
> @@ -971,7 +969,7 @@ undoSStep (thread_info * th)
> {
> if (th->stepped)
> {
> - memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
> + remove_single_step_breakpoints ();
> th->stepped = 0;
> }
> return;
> @@ -996,8 +994,7 @@ wince_software_single_step (enum target_
>
> th->stepped = 1;
> th->step_pc = sh_get_next_pc (&th->context);
> - th->step_prev = 0;
> - memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
> + insert_single_step_breakpoint (th->step_pc);
> return;
> }
> #elif defined (ARM)
> @@ -1024,7 +1021,7 @@ undoSStep (thread_info * th)
> {
> if (th->stepped)
> {
> - memory_remove_breakpoint (th->step_pc, (void *) &th->step_prev);
> + remove_single_step_breakpoints ();
> th->stepped = 0;
> }
> }
> @@ -1047,8 +1044,7 @@ wince_software_single_step (enum target_
> th->stepped = 1;
> pc = read_register (PC_REGNUM);
> th->step_pc = arm_get_next_pc (pc);
> - th->step_prev = 0;
> - memory_insert_breakpoint (th->step_pc, (void *) &th->step_prev);
> + insert_single_step_breakpoint (th->step_pc);
> return;
> }
> #endif
> Index: config/i386/nm-i386.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/config/i386/nm-i386.h,v
> retrieving revision 1.7
> diff -u -p -r1.7 nm-i386.h
> --- config/i386/nm-i386.h 8 Oct 2004 17:30:48 -0000 1.7
> +++ config/i386/nm-i386.h 17 Apr 2006 19:03:28 -0000
> @@ -52,13 +52,14 @@ extern int i386_stopped_by_hwbp (void);
> true. Otherwise, return false. */
> extern int i386_stopped_data_address (CORE_ADDR *);
>
> -/* Insert a hardware-assisted breakpoint at address ADDR. SHADOW is
> - unused. Return 0 on success, EBUSY on failure. */
> -extern int i386_insert_hw_breakpoint (CORE_ADDR addr, void *shadow);
> -
> -/* Remove a hardware-assisted breakpoint at address ADDR. SHADOW is
> - unused. Return 0 on success, -1 on failure. */
> -extern int i386_remove_hw_breakpoint (CORE_ADDR addr, void *shadow);
> +/* Insert a hardware-assisted breakpoint at BP_TGT->placed_address.
> + Return 0 on success, EBUSY on failure. */
> +struct bp_target_info;
> +extern int i386_insert_hw_breakpoint (struct bp_target_info *bp_tgt);
> +
> +/* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
> + Return 0 on success, -1 on failure. */
> +extern int i386_remove_hw_breakpoint (struct bp_target_info *bp_tgt);
>
> /* Returns the number of hardware watchpoints of type TYPE that we can
> set. Value is positive if we can set CNT watchpoints, zero if
> @@ -105,11 +106,11 @@ extern int i386_stopped_by_watchpoint (v
> #define target_remove_watchpoint(addr, len, type) \
> i386_remove_watchpoint (addr, len, type)
>
> -#define target_insert_hw_breakpoint(addr, shadow) \
> - i386_insert_hw_breakpoint (addr, shadow)
> +#define target_insert_hw_breakpoint(bp_tgt) \
> + i386_insert_hw_breakpoint (bp_tgt)
>
> -#define target_remove_hw_breakpoint(addr, shadow) \
> - i386_remove_hw_breakpoint (addr, shadow)
> +#define target_remove_hw_breakpoint(bp_tgt) \
> + i386_remove_hw_breakpoint (bp_tgt)
>
> /* child_post_startup_inferior used to
> reset all debug registers by calling i386_cleanup_dregs (). */
> Index: doc/gdbint.texinfo
> ===================================================================
> RCS file: /cvs/src/src/gdb/doc/gdbint.texinfo,v
> retrieving revision 1.240
> diff -u -p -r1.240 gdbint.texinfo
> --- doc/gdbint.texinfo 28 Mar 2006 19:19:16 -0000 1.240
> +++ doc/gdbint.texinfo 17 Apr 2006 19:03:30 -0000
> @@ -527,6 +527,44 @@ The basic definition of the software bre
> Basic breakpoint object handling is in @file{breakpoint.c}. However,
> much of the interesting breakpoint action is in @file{infrun.c}.
>
> +@table @code
> +@cindex insert or remove software breakpoint
> +@findex target_remove_breakpoint
> +@findex target_insert_breakpoint
> +@item target_remove_breakpoint (@var{bp_tgt})
> +@itemx target_insert_breakpoint (@var{bp_tgt})
> +Insert or remove a software breakpoint at address
> +@code{@var{bp_tgt}->placed_address}. Returns zero for success,
> +non-zero for failure. On input, @var{bp_tgt} contains the address of the
> +breakpoint, and is otherwise initialized to zero. @var{bp_tgt} is updated
> +to contain other information about the breakpoint on output:
> +@code{placed_address} may be updated if the breakpoint was placed at a
> +related address; @code{shadow_contents} is the real contents of the bytes
> +where the breakpoint has been inserted, if reading memory would return
> +the breakpoint instead of the underlying memory; @code{shadow_len} is the
> +length of memory cached in @code{shadow_contents}, if any; and
> +@code{placed_size} is optionally set and used by the target, if
> +it could differ from @code{shadow_len}.
> +
> +For example, the remote target @samp{Z0} packet does not require
> +shadowing memory, so @code{shadow_len} is left at zero. However,
> +the length reported by @code{BREAKPOINT_FROM_PC} is cached in
> +@code{placed_size}, so that a matching @samp{z0} packet can be
> +used to remove the breakpoint.
> +
> +@cindex insert or remove hardware breakpoint
> +@findex target_remove_hw_breakpoint
> +@findex target_insert_hw_breakpoint
> +@item target_remove_hw_breakpoint (@var{bp_tgt})
> +@itemx target_insert_hw_breakpoint (@var{bp_tgt})
> +Insert or remove a hardware-assisted breakpoint at address
> +@code{@var{bp_tgt}->placed_address}. Returns zero for success,
> +non-zero for failure. See @code{target_insert_breakpoint} for
> +a description of @var{bp_tgt}; the @code{shadow_contents} and
> +@code{shadow_len} members are not used for hardware breakpoints,
> +but @code{placed_size} may be.
> +@end table
> +
> @section Single Stepping
>
> @section Signal Handling
> @@ -657,18 +695,6 @@ defined by @file{breakpoint.h} as follow
> @noindent
> These two macros should return 0 for success, non-zero for failure.
>
> -@cindex insert or remove hardware breakpoint
> -@findex target_remove_hw_breakpoint
> -@findex target_insert_hw_breakpoint
> -@item target_remove_hw_breakpoint (@var{addr}, @var{shadow})
> -@itemx target_insert_hw_breakpoint (@var{addr}, @var{shadow})
> -Insert or remove a hardware-assisted breakpoint at address @var{addr}.
> -Returns zero for success, non-zero for failure. @var{shadow} is the
> -real contents of the byte where the breakpoint has been inserted; it
> -is generally not valid when hardware breakpoints are used, but since
> -no other code touches these values, the implementations of the above
> -two macros can use them for their internal purposes.
> -
> @findex target_stopped_data_address
> @item target_stopped_data_address (@var{addr_p})
> If the inferior has some watchpoint that triggered, place the address
> @@ -858,8 +884,8 @@ the count goes to zero.
>
> @findex i386_insert_hw_breakpoint
> @findex i386_remove_hw_breakpoint
> -@item i386_insert_hw_breakpoint (@var{addr}, @var{shadow}
> -@itemx i386_remove_hw_breakpoint (@var{addr}, @var{shadow})
> +@item i386_insert_hw_breakpoint (@var{bp_tgt})
> +@itemx i386_remove_hw_breakpoint (@var{bp_tgt})
> These functions insert and remove hardware-assisted breakpoints. The
> macros @code{target_insert_hw_breakpoint} and
> @code{target_remove_hw_breakpoint} are set to call these functions.
> @@ -3229,8 +3255,8 @@ instruction of the architecture.
>
> Replaces all the other @var{BREAKPOINT} macros.
>
> -@item MEMORY_INSERT_BREAKPOINT (@var{addr}, @var{contents_cache})
> -@itemx MEMORY_REMOVE_BREAKPOINT (@var{addr}, @var{contents_cache})
> +@item MEMORY_INSERT_BREAKPOINT (@var{bp_tgt})
> +@itemx MEMORY_REMOVE_BREAKPOINT (@var{bp_tgt})
> @findex MEMORY_REMOVE_BREAKPOINT
> @findex MEMORY_INSERT_BREAKPOINT
> Insert or remove memory based breakpoints. Reasonable defaults
>