[GDBserver] Make Zx/zx packet handling idempotent.

This patch fixes hardware breakpoint regressions exposed by my fix for
"PR breakpoints/7143 - Watchpoint does not trigger when first set", at
https://sourceware.org/ml/gdb-patches/2014-03/msg00167.html

The testsuite caught them on Linux/x86_64, at least.  gdb.sum:

gdb.sum:

 FAIL: gdb.base/hbreak2.exp: next over recursive call
 FAIL: gdb.base/hbreak2.exp: backtrace from factorial(5.1)
 FAIL: gdb.base/hbreak2.exp: continue until exit at recursive next test

gdb.log:

 (gdb) next

 Program received signal SIGTRAP, Trace/breakpoint trap.
 factorial (value=4) at ../../../src/gdb/testsuite/gdb.base/break.c:113
 113       if (value > 1) {  /* set breakpoint 7 here */
 (gdb) FAIL: gdb.base/hbreak2.exp: next over recursive call

Actually, that patch just exposed a latent issue to "breakpoints
always-inserted off" mode, not really caused it.  After that patch,
GDB no longer removes breakpoints at each internal event, thus making
some scenarios behave like breakpoint always-inserted on.  The bug is
easy to trigger with always-inserted on.

The issue is that since the target-side breakpoint conditions support,
if the stub/server supports evaluating breakpoint conditions on the
target side, then GDB is sending duplicate Zx packets to the target
without removing them before, and GDBserver is not really expecting
that for Z packets other than Z0/z0.  E.g., with "set breakpoint
always-inserted on" and "set debug remote 1":

 (gdb) b main
 Sending packet: $m410943,1#ff...Packet received: 48
 Breakpoint 4 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line 3028.
 Sending packet: $Z0,410943,1#48...Packet received: OK
                 ^^^^^^^^^^^^
 (gdb) b main
 Note: breakpoint 4 also set at pc 0x410943.
 Sending packet: $m410943,1#ff...Packet received: 48
 Breakpoint 5 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line 3028.
 Sending packet: $Z0,410943,1#48...Packet received: OK
                 ^^^^^^^^^^^^
 (gdb) b main
 Note: breakpoints 4 and 5 also set at pc 0x410943.
 Sending packet: $m410943,1#ff...Packet received: 48
 Breakpoint 6 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line 3028.
 Sending packet: $Z0,410943,1#48...Packet received: OK
                 ^^^^^^^^^^^^
 (gdb) del
 Delete all breakpoints? (y or n) y
 Sending packet: $Z0,410943,1#48...Packet received: OK
 Sending packet: $Z0,410943,1#48...Packet received: OK
 Sending packet: $z0,410943,1#68...Packet received: OK

And for Z1, similarly:

 (gdb) hbreak main
 Sending packet: $m410943,1#ff...Packet received: 48
 Hardware assisted breakpoint 4 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line 3028.
 Sending packet: $Z1,410943,1#49...Packet received: OK
                 ^^^^^^^^^^^^
 Packet Z1 (hardware-breakpoint) is supported
 (gdb) hbreak main
 Note: breakpoint 4 also set at pc 0x410943.
 Sending packet: $m410943,1#ff...Packet received: 48
 Hardware assisted breakpoint 5 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line 3028.
 Sending packet: $Z1,410943,1#49...Packet received: OK
                 ^^^^^^^^^^^^
 (gdb) hbreak main
 Note: breakpoints 4 and 5 also set at pc 0x410943.
 Sending packet: $m410943,1#ff...Packet received: 48
 Hardware assisted breakpoint 6 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line 3028.
 Sending packet: $Z1,410943,1#49...Packet received: OK
                 ^^^^^^^^^^^^
 (gdb) del
 Delete all breakpoints? (y or n) y
 Sending packet: $Z1,410943,1#49...Packet received: OK
                 ^^^^^^^^^^^^
 Sending packet: $Z1,410943,1#49...Packet received: OK
                 ^^^^^^^^^^^^
 Sending packet: $z1,410943,1#69...Packet received: OK
                 ^^^^^^^^^^^^

So GDB sent a bunch of Z1 packets, and then when finally removing the
breakpoint, only one z1 packet was sent.  On the GDBserver side (with
monitor set debug-hw-points 1), in the Z1 case, we see:

 $ ./gdbserver :9999 ./gdbserver
 Process ./gdbserver created; pid = 8629
 Listening on port 9999
 Remote debugging from host 127.0.0.1
 insert_watchpoint (addr=410943, len=1, type=instruction-execute):
	 CONTROL (DR7): 00000101          STATUS (DR6): 00000000
	 DR0: addr=0x410943, ref.count=1  DR1: addr=0x0, ref.count=0
	 DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
 insert_watchpoint (addr=410943, len=1, type=instruction-execute):
	 CONTROL (DR7): 00000101          STATUS (DR6): 00000000
	 DR0: addr=0x410943, ref.count=2  DR1: addr=0x0, ref.count=0
	 DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
 insert_watchpoint (addr=410943, len=1, type=instruction-execute):
	 CONTROL (DR7): 00000101          STATUS (DR6): 00000000
	 DR0: addr=0x410943, ref.count=3  DR1: addr=0x0, ref.count=0
	 DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
 insert_watchpoint (addr=410943, len=1, type=instruction-execute):
	 CONTROL (DR7): 00000101          STATUS (DR6): 00000000
	 DR0: addr=0x410943, ref.count=4  DR1: addr=0x0, ref.count=0
	 DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
 insert_watchpoint (addr=410943, len=1, type=instruction-execute):
	 CONTROL (DR7): 00000101          STATUS (DR6): 00000000
	 DR0: addr=0x410943, ref.count=5  DR1: addr=0x0, ref.count=0
	 DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
 remove_watchpoint (addr=410943, len=1, type=instruction-execute):
	 CONTROL (DR7): 00000101          STATUS (DR6): 00000000
	 DR0: addr=0x410943, ref.count=4  DR1: addr=0x0, ref.count=0
	 DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0

That's one insert_watchpoint call for each Z1 packet, and then one
remove_watchpoint call for the z1 packet.  Notice how ref.count
increased for each insert_watchpoint call, and then in the end, after
GDB told GDBserver to forget about the hardware breakpoint, GDBserver
ends with the the first debug register still with ref.count=4!  IOW,
the hardware breakpoint is left armed on the target, while on the GDB
end it's gone.  If the program happens to execute 0x410943 afterwards,
then the CPU traps, GDBserver reports the trap to GDB, and GDB not
having a breakpoint set at that address anymore, reports to the user a
spurious SIGTRAP.

This is exactly what is happening in the hbreak2.exp test, though in
that case, it's a shared library event that triggers a
breakpoint_re_set, when breakpoints are still inserted (because
nowadays GDB doesn't remove breakpoints while handling internal
events), and that recreates breakpoint locations, which likewise
forces breakpoint reinsertion and Zx packet resends...

That is a lot of bogus Zx duplication that should possibly be
addressed on the GDB side.  GDB resends Zx packets because the way to
change the target-side condition, is to resend the breakpoint to the
server with the new condition.  (That's an option in the packet: e.g.,
"Z1,410943,1;X3,220027" for "hbreak main if 0".  The packets in the
examples above are shorter because the breakpoints don't have
conditions attached).  GDB doesn't remove the breakpoint first before
reinserting it because that'd be bad for non-stop, as it'd open a
window where the inferior could miss the breakpoint.  The conditions
actually haven't changed between the resends, but GDB isn't smart
enough to realize that.

(TBC, if the target doesn't support target-side conditions, then GDB
doesn't trigger these resends (init_bp_location calls
mark_breakpoint_location_modified, and that does nothing if condition
evaluation is on the host side.  The resends are caused by the
'loc->condition_changed = condition_modified.'  line.)

But, even if GDB was made smarter, GDBserver should really still
handle the resends anyway.  So target-side conditions also aren't
really to blame.  The documentation of the Z/z packets says:

 "To avoid potential problems with duplicate packets, the operations
 should be implemented in an idempotent way."

As such, we may want to fix GDB, but we should definitely fix
GDBserver.  The fix is a prerequisite for target-side conditions on
hardware breakpoints anyway (and while at it, on watchpoints too).

GDBserver indeed already treats duplicate Z0 packets in an idempotent
way.  mem-break.c has the concept of high-level and low-level
breakpoints, somewhat similar to GDB's split of breakpoints vs
breakpoint locations, and keeps track of multiple breakpoints
referencing the same address/location, for the case of an internal
GDBserver breakpoint or a tracepoint being set at the same address as
a GDB breakpoint.  But, it only allows GDB to ever contribute one
reference to a software breakpoint location.  IOW, if gdbserver sees a
Z0 packet for the same address where it already had a GDB breakpoint
set, then GDBserver won't create another high-level GDB breakpoint.

However, mem-break.c only tracks GDB Z0 breakpoints.  The same logic
should apply to all kinds of Zx packets.  Currently, gdbserver passes
down each duplicate Zx (other than Z0) request directly to the
target->insert_point routine.  The x86 watchpoint support itself
refcounts watchpoint / hw breakpoint requests, to handle overlapping
watchpoints, and save debug registers.  But that code doesn't (and
really shouldn't) handle the duplicate requests, assuming that for
each insert there will be a corresponding remove.

So the fix is to generalize mem-break.c to track all kinds of Zx
breakpoints, and filter out duplicates.  As mentioned, this ends up
adding support for target-side conditions on hardware breakpoints and
watchpoints too (though GDB itself doesn't support the latter yet).

Probably the least obvious change in the patch is that it kind of
turns the breakpoint insert/remove APIs inside out.  Before, the
target methods were only called for GDB breakpoints.  The internal
breakpoint set/delete methods inserted memory breakpoints directly
bypassing the insert/remove target methods.  That's not good when the
target should use a debug API to set software breakpoints, instead of
relying on GDBserver patching memory with breakpoint instructions, as
is the case of NTO.

Now removal/insertion of all kinds of breakpoints/watchpoints, either
internal, or from GDB, always go through the target methods.  The
insert_point/remove_point methods no longer get passed a Z packet
type, but an internal/raw breakpoint type.  They're also passed a
pointer to the raw breakpoint itself (note that's still opaque outside
mem-break.c), so that insert_memory_breakpoint /
remove_memory_breakpoint have access to the breakpoint's shadow
buffer.  I first tried passing down a new structure based on GDB's
"struct bp_target_info" (actually with that name exactly), but then
decided against it as unnecessary complication.

As software/memory breakpoints work by poking at memory, when setting
a GDB Z0 breakpoint (but not internal breakpoints, as those can assume
the conditions are already right), we need to tell the target to
prepare to access memory (which on Linux means stop threads).  If that
operation fails, we need to return error to GDB.  Seeing an error, if
this is the first breakpoint of that type that GDB tries to insert,
GDB would then assume the breakpoint type is supported, but it may
actually not be.  So we need to check whether the type is supported at
all before preparing to access memory.  And to solve that, the patch
adds a new target->supports_z_point_type method that is called before
actually trying to insert the breakpoint.

Other than that, hopefully the change is more or less obvious.

New test added that exercises the hbreak2.exp regression in a more
direct way, without relying on a breakpoint re-set happening before
main is reached.

Tested by building GDBserver for:

 aarch64-linux-gnu
 arm-linux-gnueabihf
 i686-pc-linux-gnu
 i686-w64-mingw32
 m68k-linux-gnu
 mips-linux-gnu
 mips-uclinux
 nios2-linux-gnu
 powerpc-linux-gnu
 sh-linux-gnu
 tilegx-unknown-linux-gnu
 x86_64-redhat-linux
 x86_64-w64-mingw32

And also regression tested on x86_64 Fedora 20.

gdb/gdbserver/
2014-05-20  Pedro Alves  <palves@redhat.com>

	* linux-aarch64-low.c (aarch64_insert_point)
	(aarch64_remove_point): No longer check whether the type is
	supported here.  Adjust to new interface.
	(the_low_target): Install aarch64_supports_z_point_type as
	supports_z_point_type method.
	* linux-arm-low.c (raw_bkpt_type_to_arm_hwbp_type): New function.
	(arm_linux_hw_point_initialize): Take an enum raw_bkpt_type
	instead of a Z packet char.  Adjust.
	(arm_supports_z_point_type): New function.
	(arm_insert_point, arm_remove_point): Adjust to new interface.
	(the_low_target): Install arm_supports_z_point_type.
	* linux-crisv32-low.c (cris_supports_z_point_type): New function.
	(cris_insert_point, cris_remove_point): Adjust to new interface.
	Don't check whether the type is supported here.
	(the_low_target): Install cris_supports_z_point_type.
	* linux-low.c (linux_supports_z_point_type): New function.
	(linux_insert_point, linux_remove_point): Adjust to new interface.
	* linux-low.h (struct linux_target_ops) <insert_point,
	remove_point>: Take an enum raw_bkpt_type instead of a char.  Add
	raw_breakpoint pointer parameter.
	<supports_z_point_type>: New method.
	* linux-mips-low.c (mips_supports_z_point_type): New function.
	(mips_insert_point, mips_remove_point): Adjust to new interface.
	Use mips_supports_z_point_type.
	(the_low_target): Install mips_supports_z_point_type.
	* linux-ppc-low.c (the_low_target): Install NULL as
	supports_z_point_type method.
	* linux-s390-low.c (the_low_target): Install NULL as
	supports_z_point_type method.
	* linux-sparc-low.c (the_low_target): Install NULL as
	supports_z_point_type method.
	* linux-x86-low.c (x86_supports_z_point_type): New function.
	(x86_insert_point): Adjust to new insert_point interface.  Use
	insert_memory_breakpoint.  Adjust to new
	i386_low_insert_watchpoint interface.
	(x86_remove_point): Adjust to remove_point interface.  Use
	remove_memory_breakpoint.  Adjust to new
	i386_low_remove_watchpoint interface.
	(the_low_target): Install x86_supports_z_point_type.
	* lynx-low.c (lynx_target_ops): Install NULL as
	supports_z_point_type callback.
	* nto-low.c (nto_supports_z_point_type): New.
	(nto_insert_point, nto_remove_point): Adjust to new interface.
	(nto_target_ops): Install nto_supports_z_point_type.
	* mem-break.c: Adjust intro comment.
	(struct raw_breakpoint) <raw_type, size>: New fields.
	<inserted>: Update comment.
	<shlib_disabled>: Delete field.
	(enum bkpt_type) <gdb_breakpoint>: Delete value.
	<gdb_breakpoint_Z0, gdb_breakpoint_Z1, gdb_breakpoint_Z2,
	gdb_breakpoint_Z3, gdb_breakpoint_Z4>: New values.
	(raw_bkpt_type_to_target_hw_bp_type): New function.
	(find_enabled_raw_code_breakpoint_at): New function.
	(find_raw_breakpoint_at): New type and size parameters.  Use them.
	(insert_memory_breakpoint): New function, based off
	set_raw_breakpoint_at.
	(remove_memory_breakpoint): New function.
	(set_raw_breakpoint_at): Reimplement.
	(set_breakpoint): New, based on set_breakpoint_at.
	(set_breakpoint_at): Reimplement.
	(delete_raw_breakpoint): Go through the_target->remove_point
	instead of assuming memory breakpoints.
	(find_gdb_breakpoint_at): Delete.
	(Z_packet_to_bkpt_type, Z_packet_to_raw_bkpt_type): New functions.
	(find_gdb_breakpoint): New function.
	(set_gdb_breakpoint_at): Delete.
	(z_type_supported): New function.
	(set_gdb_breakpoint_1): New function, loosely based off
	set_gdb_breakpoint_at.
	(check_gdb_bp_preconditions, set_gdb_breakpoint): New functions.
	(delete_gdb_breakpoint_at): Delete.
	(delete_gdb_breakpoint_1): New function, loosely based off
	delete_gdb_breakpoint_at.
	(delete_gdb_breakpoint): New function.
	(clear_gdb_breakpoint_conditions): Rename to ...
	(clear_breakpoint_conditions): ... this.  Don't handle a NULL
	breakpoint.
	(add_condition_to_breakpoint): Make static.
	(add_breakpoint_condition): Take a struct breakpoint pointer
	instead of an address.  Adjust.
	(gdb_condition_true_at_breakpoint): Rename to ...
	(gdb_condition_true_at_breakpoint_z_type): ... this, and add
	z_type parameter.
	(gdb_condition_true_at_breakpoint): Reimplement.
	(add_breakpoint_commands): Take a struct breakpoint pointer
	instead of an address.  Adjust.
	(gdb_no_commands_at_breakpoint): Rename to ...
	(gdb_no_commands_at_breakpoint_z_type): ... this.  Add z_type
	parameter.  Return true if no breakpoint was found.  Change debug
	output.
	(gdb_no_commands_at_breakpoint): Reimplement.
	(run_breakpoint_commands): Rename to ...
	(run_breakpoint_commands_z_type): ... this.  Add z_type parameter,
	and change return type to boolean.
	(run_breakpoint_commands): New function.
	(gdb_breakpoint_here): Also check for Z1 breakpoints.
	(uninsert_raw_breakpoint): Don't try to reinsert a disabled
	breakpoint.  Go through the_target->remove_point instead of
	assuming memory breakpoint.
	(uninsert_breakpoints_at, uninsert_all_breakpoints): Uninsert
	software and hardware breakpoints.
	(reinsert_raw_breakpoint): Go through the_target->insert_point
	instead of assuming memory breakpoint.
	(reinsert_breakpoints_at, reinsert_all_breakpoints): Reinsert
	software and hardware breakpoints.
	(check_breakpoints, breakpoint_here, breakpoint_inserted_here):
	Check both software and hardware breakpoints.
	(validate_inserted_breakpoint): Assert the breakpoint is a
	software breakpoint.  Set the inserted flag to -1 instead of
	setting shlib_disabled.
	(delete_disabled_breakpoints): Adjust.
	(validate_breakpoints): Only validate software breakpoints.
	Adjust to inserted flag change.
	(check_mem_read, check_mem_write): Skip breakpoint types other
	than software breakpoints.  Adjust to inserted flag change.
	* mem-break.h (enum raw_bkpt_type): New enum.
	(raw_breakpoint, struct process_info): Forward declare.
	(Z_packet_to_target_hw_bp_type): Delete declaration.
	(raw_bkpt_type_to_target_hw_bp_type, Z_packet_to_raw_bkpt_type)
	(set_gdb_breakpoint, delete_gdb_breakpoint)
	(clear_breakpoint_conditions): New declarations.
	(set_gdb_breakpoint_at, clear_gdb_breakpoint_conditions): Delete.
	(breakpoint_inserted_here): Update comment.
	(add_breakpoint_condition, add_breakpoint_commands): Replace
	address parameter with a breakpoint pointer parameter.
	(gdb_breakpoint_here): Update comment.
	(delete_gdb_breakpoint_at): Delete.
	(insert_memory_breakpoint, remove_memory_breakpoint): Declare.
	* server.c (process_point_options): Take a struct breakpoint
	pointer instead of an address.  Adjust.
	(process_serial_event) <Z/z packets>: Use set_gdb_breakpoint and
	delete_gdb_breakpoint.
	* spu-low.c (spu_target_ops): Install NULL as
	supports_z_point_type method.
	* target.h: Include mem-break.h.
	(struct target_ops) <prepare_to_access_memory>: Update comment.
	<supports_z_point_type>: New field.
	<insert_point, remove_point>: Take an enum raw_bkpt_type argument
	instead of a char.  Also take a raw breakpoint pointer.
	* win32-arm-low.c (the_low_target): Install NULL as
	supports_z_point_type.
	* win32-i386-low.c (i386_supports_z_point_type): New function.
	(i386_insert_point, i386_remove_point): Adjust to new interface.
	(the_low_target): Install i386_supports_z_point_type.
	* win32-low.c (win32_supports_z_point_type): New function.
	(win32_insert_point, win32_remove_point): Adjust to new interface.
	(win32_target_ops): Install win32_supports_z_point_type.
	* win32-low.h (struct win32_target_ops):
	<supports_z_point_type>: New method.
	<insert_point, remove_point>: Take an enum raw_bkpt_type argument
	instead of a char.  Also take a raw breakpoint pointer.

gdb/testsuite/
2014-05-20  Pedro Alves  <palves@redhat.com>

	* gdb.base/break-idempotent.c: New file.
	* gdb.base/break-idempotent.exp: New file.

1 files changed, 561 insertions, 167 deletions

diff --git a/gdb/gdbserver/mem-break.c b/gdb/gdbserver/mem-break.c
index b19cbc8..daeb521 100644
--- a/gdb/gdbserver/mem-break.c
+++ b/gdb/gdbserver/mem-break.c
@@ -29,12 +29,31 @@ int breakpoint_len;
 #define MAX_BREAKPOINT_LEN 8
 
 /* GDB will never try to install multiple breakpoints at the same
-   address.  But, we need to keep track of internal breakpoints too,
-   and so we do need to be able to install multiple breakpoints at the
-   same address transparently.  We keep track of two different, and
-   closely related structures.  A raw breakpoint, which manages the
-   low level, close to the metal aspect of a breakpoint.  It holds the
-   breakpoint address, and a buffer holding a copy of the instructions
+   address.  However, we can see GDB requesting to insert a breakpoint
+   at an address is had already inserted one previously in a few
+   situations.
+
+   - The RSP documentation on Z packets says that to avoid potential
+   problems with duplicate packets, the operations should be
+   implemented in an idempotent way.
+
+   - A breakpoint is set at ADDR, an address in a shared library.
+   Then the shared library is unloaded.  And then another, unrelated,
+   breakpoint at ADDR is set.  There is not breakpoint removal request
+   between the first and the second breakpoint.
+
+   - When GDB wants to update the target-side breakpoint conditions or
+   commands, it re-inserts the breakpoint, with updated
+   conditions/commands associated.
+
+   Also, we need to keep track of internal breakpoints too, so we do
+   need to be able to install multiple breakpoints at the same address
+   transparently.
+
+   We keep track of two different, and closely related structures.  A
+   raw breakpoint, which manages the low level, close to the metal
+   aspect of a breakpoint.  It holds the breakpoint address, and for
+   software breakpoints, a buffer holding a copy of the instructions
    that would be in memory had not been a breakpoint there (we call
    that the shadow memory of the breakpoint).  We occasionally need to
    temporarilly uninsert a breakpoint without the client knowing about
@@ -53,6 +72,10 @@ struct raw_breakpoint
 {
   struct raw_breakpoint *next;
 
+  /* The low level type of the breakpoint (software breakpoint,
+     watchpoint, etc.)  */
+  enum raw_bkpt_type raw_type;
+
   /* A reference count.  Each high level breakpoint referencing this
      raw breakpoint accounts for one reference.  */
   int refcount;
@@ -61,23 +84,35 @@ struct raw_breakpoint
      breakpoint for a given PC.  */
   CORE_ADDR pc;
 
+  /* The breakpoint's size.  */
+  int size;
+
   /* The breakpoint's shadow memory.  */
   unsigned char old_data[MAX_BREAKPOINT_LEN];
 
-  /* Non-zero if this breakpoint is currently inserted in the
-     inferior.  */
+  /* Positive if this breakpoint is currently inserted in the
+     inferior.  Negative if it was, but we've detected that it's now
+     gone.  Zero if not inserted.  */
   int inserted;
-
-  /* Non-zero if this breakpoint is currently disabled because we no
-     longer detect it as inserted.  */
-  int shlib_disabled;
 };
 
 /* The type of a breakpoint.  */
 enum bkpt_type
   {
     /* A GDB breakpoint, requested with a Z0 packet.  */
-    gdb_breakpoint,
+    gdb_breakpoint_Z0,
+
+    /* A GDB hardware breakpoint, requested with a Z1 packet.  */
+    gdb_breakpoint_Z1,
+
+    /* A GDB write watchpoint, requested with a Z2 packet.  */
+    gdb_breakpoint_Z2,
+
+    /* A GDB read watchpoint, requested with a Z3 packet.  */
+    gdb_breakpoint_Z3,
+
+    /* A GDB access watchpoint, requested with a Z4 packet.  */
+    gdb_breakpoint_Z4,
 
     /* A basic-software-single-step breakpoint.  */
     reinsert_breakpoint,
@@ -138,21 +173,55 @@ struct breakpoint
   int (*handler) (CORE_ADDR);
 };
 
+/* See mem-break.h.  */
+
 enum target_hw_bp_type
-Z_packet_to_target_hw_bp_type (char type)
+raw_bkpt_type_to_target_hw_bp_type (enum raw_bkpt_type raw_type)
 {
-  switch (type)
+  switch (raw_type)
     {
-    case Z_PACKET_HW_BP:
+    case raw_bkpt_type_hw:
       return hw_execute;
-    case Z_PACKET_WRITE_WP:
+    case raw_bkpt_type_write_wp:
       return hw_write;
-    case Z_PACKET_READ_WP:
+    case raw_bkpt_type_read_wp:
       return hw_read;
-    case Z_PACKET_ACCESS_WP:
+    case raw_bkpt_type_access_wp:
       return hw_access;
     default:
-      fatal ("bad watchpoint type %c", type);
+      fatal ("bad raw breakpoing type %d", (int) raw_type);
+    }
+}
+
+/* See mem-break.h.  */
+
+static enum bkpt_type
+Z_packet_to_bkpt_type (char z_type)
+{
+  gdb_assert ('0' <= z_type && z_type <= '4');
+
+  return gdb_breakpoint_Z0 + (z_type - '0');
+}
+
+/* See mem-break.h.  */
+
+enum raw_bkpt_type
+Z_packet_to_raw_bkpt_type (char z_type)
+{
+  switch (z_type)
+    {
+    case Z_PACKET_SW_BP:
+      return raw_bkpt_type_sw;
+    case Z_PACKET_HW_BP:
+      return raw_bkpt_type_hw;
+    case Z_PACKET_WRITE_WP:
+      return raw_bkpt_type_write_wp;
+    case Z_PACKET_READ_WP:
+      return raw_bkpt_type_read_wp;
+    case Z_PACKET_ACCESS_WP:
+      return raw_bkpt_type_access_wp;
+    default:
+      gdb_assert_not_reached ("unhandled Z packet type.");
     }
 }
 
@@ -173,69 +242,169 @@ any_persistent_commands ()
   return 0;
 }
 
+/* Find low-level breakpoint of type TYPE at address ADDR that is not
+   insert-disabled.  Returns NULL if not found.  */
+
 static struct raw_breakpoint *
-find_raw_breakpoint_at (CORE_ADDR where)
+find_enabled_raw_code_breakpoint_at (CORE_ADDR addr, enum raw_bkpt_type type)
 {
   struct process_info *proc = current_process ();
   struct raw_breakpoint *bp;
 
   for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
-    if (bp->pc == where)
+    if (bp->pc == addr
+	&& bp->raw_type == type
+	&& bp->inserted >= 0)
       return bp;
 
   return NULL;
 }
 
+/* Find low-level breakpoint of type TYPE at address ADDR.  Returns
+   NULL if not found.  */
+
 static struct raw_breakpoint *
-set_raw_breakpoint_at (CORE_ADDR where)
+find_raw_breakpoint_at (CORE_ADDR addr, enum raw_bkpt_type type, int size)
 {
   struct process_info *proc = current_process ();
   struct raw_breakpoint *bp;
-  int err;
+
+  for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+    if (bp->pc == addr && bp->raw_type == type && bp->size == size)
+      return bp;
+
+  return NULL;
+}
+
+/* See mem-break.h.  */
+
+int
+insert_memory_breakpoint (struct raw_breakpoint *bp)
+{
   unsigned char buf[MAX_BREAKPOINT_LEN];
+  int err;
 
   if (breakpoint_data == NULL)
-    error ("Target does not support breakpoints.");
+    return 1;
 
-  bp = find_raw_breakpoint_at (where);
-  if (bp != NULL)
+  /* If the architecture treats the size field of Z packets as a
+     'kind' field, then we'll need to be able to know which is the
+     breakpoint instruction too.  */
+  if (bp->size != breakpoint_len)
     {
-      bp->refcount++;
-      return bp;
+      if (debug_threads)
+	debug_printf ("Don't know how to insert breakpoints of size %d.\n",
+		      bp->size);
+      return -1;
     }
 
-  bp = xcalloc (1, sizeof (*bp));
-  bp->pc = where;
-  bp->refcount = 1;
-
   /* Note that there can be fast tracepoint jumps installed in the
      same memory range, so to get at the original memory, we need to
      use read_inferior_memory, which masks those out.  */
-  err = read_inferior_memory (where, buf, breakpoint_len);
+  err = read_inferior_memory (bp->pc, buf, breakpoint_len);
   if (err != 0)
     {
       if (debug_threads)
 	debug_printf ("Failed to read shadow memory of"
 		      " breakpoint at 0x%s (%s).\n",
-		      paddress (where), strerror (err));
-      free (bp);
-      return NULL;
+		      paddress (bp->pc), strerror (err));
     }
-  memcpy (bp->old_data, buf, breakpoint_len);
+  else
+    {
+      memcpy (bp->old_data, buf, breakpoint_len);
 
-  err = (*the_target->write_memory) (where, breakpoint_data,
-				     breakpoint_len);
+      err = (*the_target->write_memory) (bp->pc, breakpoint_data,
+					 breakpoint_len);
+      if (err != 0)
+	{
+	  if (debug_threads)
+	    debug_printf ("Failed to insert breakpoint at 0x%s (%s).\n",
+			  paddress (bp->pc), strerror (err));
+	}
+    }
+  return err != 0 ? -1 : 0;
+}
+
+/* See mem-break.h  */
+
+int
+remove_memory_breakpoint (struct raw_breakpoint *bp)
+{
+  unsigned char buf[MAX_BREAKPOINT_LEN];
+  int err;
+
+  /* Since there can be trap breakpoints inserted in the same address
+     range, we use `write_inferior_memory', which takes care of
+     layering breakpoints on top of fast tracepoints, and on top of
+     the buffer we pass it.  This works because the caller has already
+     either unlinked the breakpoint or marked it uninserted.  Also
+     note that we need to pass the current shadow contents, because
+     write_inferior_memory updates any shadow memory with what we pass
+     here, and we want that to be a nop.  */
+  memcpy (buf, bp->old_data, breakpoint_len);
+  err = write_inferior_memory (bp->pc, buf, breakpoint_len);
   if (err != 0)
     {
       if (debug_threads)
-	debug_printf ("Failed to insert breakpoint at 0x%s (%s).\n",
-		      paddress (where), strerror (err));
+	debug_printf ("Failed to uninsert raw breakpoint "
+		      "at 0x%s (%s) while deleting it.\n",
+		      paddress (bp->pc), strerror (err));
+    }
+  return err != 0 ? -1 : 0;
+}
+
+/* Set a RAW breakpoint of type TYPE and size SIZE at WHERE.  On
+   success, a pointer to the new breakpoint is returned.  On failure,
+   returns NULL and writes the error code to *ERR.  */
+
+static struct raw_breakpoint *
+set_raw_breakpoint_at (enum raw_bkpt_type type, CORE_ADDR where, int size,
+		       int *err)
+{
+  struct process_info *proc = current_process ();
+  struct raw_breakpoint *bp;
+
+  if (type == raw_bkpt_type_sw || type == raw_bkpt_type_hw)
+    {
+      bp = find_enabled_raw_code_breakpoint_at (where, type);
+      if (bp != NULL && bp->size != size)
+	{
+	  /* A different size than previously seen.  The previous
+	     breakpoint must be gone then.  */
+	  if (debug_threads)
+	    debug_printf ("Inconsistent breakpoint size?  Was %d, now %d.\n",
+			  bp->size, size);
+	  bp->inserted = -1;
+	  bp = NULL;
+	}
+    }
+  else
+    bp = find_raw_breakpoint_at (where, type, size);
+
+  if (bp != NULL)
+    {
+      bp->refcount++;
+      return bp;
+    }
+
+  bp = xcalloc (1, sizeof (*bp));
+  bp->pc = where;
+  bp->size = size;
+  bp->refcount = 1;
+  bp->raw_type = type;
+
+  *err = the_target->insert_point (bp->raw_type, bp->pc, bp->size, bp);
+  if (*err != 0)
+    {
+      if (debug_threads)
+	debug_printf ("Failed to insert breakpoint at 0x%s (%d).\n",
+		      paddress (where), *err);
       free (bp);
       return NULL;
     }
 
-  /* Link the breakpoint in.  */
   bp->inserted = 1;
+  /* Link the breakpoint in.  */
   bp->next = proc->raw_breakpoints;
   proc->raw_breakpoints = bp;
   return bp;
@@ -545,14 +714,23 @@ reinsert_fast_tracepoint_jumps_at (CORE_ADDR where)
     }
 }
 
-struct breakpoint *
-set_breakpoint_at (CORE_ADDR where, int (*handler) (CORE_ADDR))
+/* Set a high-level breakpoint of type TYPE, with low level type
+   RAW_TYPE and size SIZE, at WHERE.  On success, a pointer to the new
+   breakpoint is returned.  On failure, returns NULL and writes the
+   error code to *ERR.  HANDLER is called when the breakpoint is hit.
+   HANDLER should return 1 if the breakpoint should be deleted, 0
+   otherwise.  */
+
+static struct breakpoint *
+set_breakpoint (enum bkpt_type type, enum raw_bkpt_type raw_type,
+		CORE_ADDR where, int size,
+		int (*handler) (CORE_ADDR), int *err)
 {
   struct process_info *proc = current_process ();
   struct breakpoint *bp;
   struct raw_breakpoint *raw;
 
-  raw = set_raw_breakpoint_at (where);
+  raw = set_raw_breakpoint_at (raw_type, where, size, err);
 
   if (raw == NULL)
     {
@@ -561,7 +739,7 @@ set_breakpoint_at (CORE_ADDR where, int (*handler) (CORE_ADDR))
     }
 
   bp = xcalloc (1, sizeof (struct breakpoint));
-  bp->type = other_breakpoint;
+  bp->type = type;
 
   bp->raw = raw;
   bp->handler = handler;
@@ -572,6 +750,19 @@ set_breakpoint_at (CORE_ADDR where, int (*handler) (CORE_ADDR))
   return bp;
 }
 
+/* See mem-break.h  */
+
+struct breakpoint *
+set_breakpoint_at (CORE_ADDR where, int (*handler) (CORE_ADDR))
+{
+  int err_ignored;
+
+  return set_breakpoint (other_breakpoint, raw_bkpt_type_sw,
+			 where, breakpoint_len, handler,
+			 &err_ignored);
+}
+
+
 static int
 delete_raw_breakpoint (struct process_info *proc, struct raw_breakpoint *todel)
 {
@@ -585,24 +776,14 @@ delete_raw_breakpoint (struct process_info *proc, struct raw_breakpoint *todel)
     {
       if (bp == todel)
 	{
-	  if (bp->inserted)
+	  if (bp->inserted > 0)
 	    {
 	      struct raw_breakpoint *prev_bp_link = *bp_link;
-	      unsigned char buf[MAX_BREAKPOINT_LEN];
 
 	      *bp_link = bp->next;
 
-	      /* Since there can be trap breakpoints inserted in the
-		 same address range, we use `write_inferior_memory',
-		 which takes care of layering breakpoints on top of
-		 fast tracepoints, and on top of the buffer we pass
-		 it.  This works because we've already unlinked the
-		 fast tracepoint jump above.  Also note that we need
-		 to pass the current shadow contents, because
-		 write_inferior_memory updates any shadow memory with
-		 what we pass here, and we want that to be a nop.  */
-	      memcpy (buf, bp->old_data, breakpoint_len);
-	      ret = write_inferior_memory (bp->pc, buf, breakpoint_len);
+	      ret = the_target->remove_point (bp->raw_type, bp->pc, bp->size,
+					      bp);
 	      if (ret != 0)
 		{
 		  /* Something went wrong, relink the breakpoint.  */
@@ -610,11 +791,10 @@ delete_raw_breakpoint (struct process_info *proc, struct raw_breakpoint *todel)
 
 		  if (debug_threads)
 		    debug_printf ("Failed to uninsert raw breakpoint "
-				  "at 0x%s (%s) while deleting it.\n",
-				  paddress (bp->pc), strerror (ret));
+				  "at 0x%s while deleting it.\n",
+				  paddress (bp->pc));
 		  return ret;
 		}
-
 	    }
 	  else
 	    *bp_link = bp->next;
@@ -694,88 +874,225 @@ delete_breakpoint (struct breakpoint *todel)
   return delete_breakpoint_1 (proc, todel);
 }
 
-/* Locate a breakpoint placed at address WHERE and return a pointer
-   to its structure.  */
+/* Locate a GDB breakpoint of type Z_TYPE and size SIZE placed at
+   address ADDR and return a pointer to its structure.  If SIZE is -1,
+   the breakpoints' sizes are ignored.  */
 
 static struct breakpoint *
-find_gdb_breakpoint_at (CORE_ADDR where)
+find_gdb_breakpoint (char z_type, CORE_ADDR addr, int size)
 {
   struct process_info *proc = current_process ();
   struct breakpoint *bp;
+  enum bkpt_type type = Z_packet_to_bkpt_type (z_type);
 
   for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
-    if (bp->type == gdb_breakpoint && bp->raw->pc == where)
+    if (bp->type == type && bp->raw->pc == addr
+	&& (size == -1 || bp->raw->size == size))
       return bp;
 
   return NULL;
 }
 
-int
-set_gdb_breakpoint_at (CORE_ADDR where)
+static int
+z_type_supported (char z_type)
+{
+  return (z_type >= '0' && z_type <= '4'
+	  && the_target->supports_z_point_type (z_type));
+}
+
+/* Create a new GDB breakpoint of type Z_TYPE at ADDR with size SIZE.
+   Returns a pointer to the newly created breakpoint on success.  On
+   failure returns NULL and sets *ERR to either -1 for error, or 1 if
+   Z_TYPE breakpoints are not supported on this target.  */
+
+static struct breakpoint *
+set_gdb_breakpoint_1 (char z_type, CORE_ADDR addr, int size, int *err)
 {
   struct breakpoint *bp;
+  enum bkpt_type type;
+  enum raw_bkpt_type raw_type;
+
+  /* If we see GDB inserting a second code breakpoint at the same
+     address, then either: GDB is updating the breakpoint's conditions
+     or commands; or, the first breakpoint must have disappeared due
+     to a shared library unload.  On targets where the shared
+     libraries are handled by userspace, like SVR4, for example,
+     GDBserver can't tell if a library was loaded or unloaded.  Since
+     we refcount raw breakpoints, we must be careful to make sure GDB
+     breakpoints never contribute more than one reference.  if we
+     didn't do this, in case the previous breakpoint is gone due to a
+     shared library unload, we'd just increase the refcount of the
+     previous breakpoint at this address, but the trap was not planted
+     in the inferior anymore, thus the breakpoint would never be hit.
+     Note this must be careful to not create a window where
+     breakpoints are removed from the target, for non-stop, in case
+     the target can poke at memory while the program is running.  */
+  if (z_type == Z_PACKET_SW_BP
+      || z_type == Z_PACKET_HW_BP)
+    {
+      bp = find_gdb_breakpoint (z_type, addr, -1);
 
-  if (breakpoint_data == NULL)
-    return 1;
+      if (bp != NULL)
+	{
+	  if (bp->raw->size != size)
+	    {
+	      /* A different size than previously seen.  The previous
+		 breakpoint must be gone then.  */
+	      bp->raw->inserted = -1;
+	      delete_breakpoint (bp);
+	      bp = NULL;
+	    }
+	  else if (z_type == Z_PACKET_SW_BP)
+	    {
+	      /* Check if the breakpoint is actually gone from the
+		 target, due to an solib unload, for example.  Might
+		 as well validate _all_ breakpoints.  */
+	      validate_breakpoints ();
+
+	      /* Breakpoints that don't pass validation are
+		 deleted.  */
+	      bp = find_gdb_breakpoint (z_type, addr, -1);
+	    }
+	}
+    }
+  else
+    {
+      /* Data breakpoints for the same address but different size are
+	 expected.  GDB doesn't merge these.  The backend gets to do
+	 that if it wants/can.  */
+      bp = find_gdb_breakpoint (z_type, addr, size);
+    }
 
-  /* If we see GDB inserting a second breakpoint at the same address,
-     then the first breakpoint must have disappeared due to a shared
-     library unload.  On targets where the shared libraries are
-     handled by userspace, like SVR4, for example, GDBserver can't
-     tell if a library was loaded or unloaded.  Since we refcount
-     breakpoints, if we didn't do this, we'd just increase the
-     refcount of the previous breakpoint at this address, but the trap
-     was not planted in the inferior anymore, thus the breakpoint
-     would never be hit.  */
-  bp = find_gdb_breakpoint_at (where);
   if (bp != NULL)
     {
-      delete_gdb_breakpoint_at (where);
+      /* We already know about this breakpoint, there's nothing else
+	 to do - GDB's reference is already accounted for.  Note that
+	 whether the breakpoint inserted is left as is - we may be
+	 stepping over it, for example, in which case we don't want to
+	 force-reinsert it.  */
+      return bp;
+    }
+
+  raw_type = Z_packet_to_raw_bkpt_type (z_type);
+  type = Z_packet_to_bkpt_type (z_type);
+  return set_breakpoint (type, raw_type, addr, size, NULL, err);
+}
+
+static int
+check_gdb_bp_preconditions (char z_type, int *err)
+{
+  /* As software/memory breakpoints work by poking at memory, we need
+     to prepare to access memory.  If that operation fails, we need to
+     return error.  Seeing an error, if this is the first breakpoint
+     of that type that GDB tries to insert, GDB would then assume the
+     breakpoint type is supported, but it may actually not be.  So we
+     need to check whether the type is supported at all before
+     preparing to access memory.  */
+  if (!z_type_supported (z_type))
+    {
+      *err = 1;
+      return 0;
+    }
+  else if (current_inferior == NULL)
+    {
+      *err = -1;
+      return 0;
+    }
+  else
+    return 1;
+}
+
+/* See mem-break.h.  This is a wrapper for set_gdb_breakpoint_1 that
+   knows to prepare to access memory for Z0 breakpoints.  */
 
-      /* Might as well validate all other breakpoints.  */
-      validate_breakpoints ();
+struct breakpoint *
+set_gdb_breakpoint (char z_type, CORE_ADDR addr, int size, int *err)
+{
+  struct breakpoint *bp;
+
+  if (!check_gdb_bp_preconditions (z_type, err))
+    return NULL;
+
+  /* If inserting a software/memory breakpoint, need to prepare to
+     access memory.  */
+  if (z_type == Z_PACKET_SW_BP)
+    {
+      *err = prepare_to_access_memory ();
+      if (*err != 0)
+	return NULL;
     }
 
-  bp = set_breakpoint_at (where, NULL);
-  if (bp == NULL)
-    return -1;
+  bp = set_gdb_breakpoint_1 (z_type, addr, size, err);
 
-  bp->type = gdb_breakpoint;
-  return 0;
+  if (z_type == Z_PACKET_SW_BP)
+    done_accessing_memory ();
+
+  return bp;
 }
 
-int
-delete_gdb_breakpoint_at (CORE_ADDR addr)
+/* Delete a GDB breakpoint of type Z_TYPE and size SIZE previously
+   inserted at ADDR with set_gdb_breakpoint_at.  Returns 0 on success,
+   -1 on error, and 1 if Z_TYPE breakpoints are not supported on this
+   target.  */
+
+static int
+delete_gdb_breakpoint_1 (char z_type, CORE_ADDR addr, int size)
 {
   struct breakpoint *bp;
   int err;
 
-  if (breakpoint_data == NULL)
-    return 1;
-
-  bp = find_gdb_breakpoint_at (addr);
+  bp = find_gdb_breakpoint (z_type, addr, size);
   if (bp == NULL)
     return -1;
 
   /* Before deleting the breakpoint, make sure to free
      its condition list.  */
-  clear_gdb_breakpoint_conditions (addr);
+  clear_breakpoint_conditions (bp);
   err = delete_breakpoint (bp);
-  if (err)
+  if (err != 0)
     return -1;
 
   return 0;
 }
 
-/* Clear all conditions associated with this breakpoint address.  */
+/* See mem-break.h.  This is a wrapper for delete_gdb_breakpoint that
+   knows to prepare to access memory for Z0 breakpoints.  */
+
+int
+delete_gdb_breakpoint (char z_type, CORE_ADDR addr, int size)
+{
+  int ret;
+
+  if (!check_gdb_bp_preconditions (z_type, &ret))
+    return ret;
+
+  /* If inserting a software/memory breakpoint, need to prepare to
+     access memory.  */
+  if (z_type == Z_PACKET_SW_BP)
+    {
+      int err;
+
+      err = prepare_to_access_memory ();
+      if (err != 0)
+	return -1;
+    }
+
+  ret = delete_gdb_breakpoint_1 (z_type, addr, size);
+
+  if (z_type == Z_PACKET_SW_BP)
+    done_accessing_memory ();
+
+  return ret;
+}
+
+/* Clear all conditions associated with a breakpoint.  */
 
 void
-clear_gdb_breakpoint_conditions (CORE_ADDR addr)
+clear_breakpoint_conditions (struct breakpoint *bp)
 {
-  struct breakpoint *bp = find_gdb_breakpoint_at (addr);
   struct point_cond_list *cond;
 
-  if (bp == NULL || bp->cond_list == NULL)
+  if (bp->cond_list == NULL)
     return;
 
   cond = bp->cond_list;
@@ -796,7 +1113,7 @@ clear_gdb_breakpoint_conditions (CORE_ADDR addr)
 
 /* Add condition CONDITION to GDBserver's breakpoint BP.  */
 
-void
+static void
 add_condition_to_breakpoint (struct breakpoint *bp,
 			     struct agent_expr *condition)
 {
@@ -811,12 +1128,11 @@ add_condition_to_breakpoint (struct breakpoint *bp,
   bp->cond_list = new_cond;
 }
 
-/* Add a target-side condition CONDITION to the breakpoint at ADDR.  */
+/* Add a target-side condition CONDITION to a breakpoint.  */
 
 int
-add_breakpoint_condition (CORE_ADDR addr, char **condition)
+add_breakpoint_condition (struct breakpoint *bp, char **condition)
 {
-  struct breakpoint *bp = find_gdb_breakpoint_at (addr);
   char *actparm = *condition;
   struct agent_expr *cond;
 
@@ -845,11 +1161,11 @@ add_breakpoint_condition (CORE_ADDR addr, char **condition)
 /* Evaluate condition (if any) at breakpoint BP.  Return 1 if
    true and 0 otherwise.  */
 
-int
-gdb_condition_true_at_breakpoint (CORE_ADDR where)
+static int
+gdb_condition_true_at_breakpoint_z_type (char z_type, CORE_ADDR addr)
 {
   /* Fetch registers for the current inferior.  */
-  struct breakpoint *bp = find_gdb_breakpoint_at (where);
+  struct breakpoint *bp = find_gdb_breakpoint (z_type, addr, -1);
   ULONGEST value = 0;
   struct point_cond_list *cl;
   int err = 0;
@@ -885,6 +1201,14 @@ gdb_condition_true_at_breakpoint (CORE_ADDR where)
   return (value != 0);
 }
 
+int
+gdb_condition_true_at_breakpoint (CORE_ADDR where)
+{
+  /* Only check code (software or hardware) breakpoints.  */
+  return (gdb_condition_true_at_breakpoint_z_type (Z_PACKET_SW_BP, where)
+	  || gdb_condition_true_at_breakpoint_z_type (Z_PACKET_HW_BP, where));
+}
+
 /* Add commands COMMANDS to GDBserver's breakpoint BP.  */
 
 void
@@ -906,9 +1230,9 @@ add_commands_to_breakpoint (struct breakpoint *bp,
 /* Add a target-side command COMMAND to the breakpoint at ADDR.  */
 
 int
-add_breakpoint_commands (CORE_ADDR addr, char **command, int persist)
+add_breakpoint_commands (struct breakpoint *bp, char **command,
+			 int persist)
 {
-  struct breakpoint *bp = find_gdb_breakpoint_at (addr);
   char *actparm = *command;
   struct agent_expr *cmd;
 
@@ -936,33 +1260,48 @@ add_breakpoint_commands (CORE_ADDR addr, char **command, int persist)
 
 /* Return true if there are no commands to run at this location,
    which likely means we want to report back to GDB.  */
-int
-gdb_no_commands_at_breakpoint (CORE_ADDR where)
+
+static int
+gdb_no_commands_at_breakpoint_z_type (char z_type, CORE_ADDR addr)
 {
-  struct breakpoint *bp = find_gdb_breakpoint_at (where);
+  struct breakpoint *bp = find_gdb_breakpoint (z_type, addr, -1);
 
   if (bp == NULL)
-    return 0;
+    return 1;
 
   if (debug_threads)
-    debug_printf ("at 0x%s, bp command_list is 0x%s\n",
-		  paddress (where),
+    debug_printf ("at 0x%s, type Z%c, bp command_list is 0x%s\n",
+		  paddress (addr), z_type,
 		  phex_nz ((uintptr_t) bp->command_list, 0));
   return (bp->command_list == NULL);
 }
 
-void
-run_breakpoint_commands (CORE_ADDR where)
+/* Return true if there are no commands to run at this location,
+   which likely means we want to report back to GDB.  */
+
+int
+gdb_no_commands_at_breakpoint (CORE_ADDR where)
+{
+  /* Only check code (software or hardware) breakpoints.  */
+  return (gdb_no_commands_at_breakpoint_z_type (Z_PACKET_SW_BP, where)
+	  && gdb_no_commands_at_breakpoint_z_type (Z_PACKET_HW_BP, where));
+}
+
+/* Run a breakpoint's commands.  Returns 0 if there was a problem
+   running any command, 1 otherwise.  */
+
+static int
+run_breakpoint_commands_z_type (char z_type, CORE_ADDR addr)
 {
   /* Fetch registers for the current inferior.  */
-  struct breakpoint *bp = find_gdb_breakpoint_at (where);
+  struct breakpoint *bp = find_gdb_breakpoint (z_type, addr, -1);
   ULONGEST value = 0;
   struct point_command_list *cl;
   int err = 0;
   struct eval_agent_expr_context ctx;
 
   if (bp == NULL)
-    return;
+    return 1;
 
   ctx.regcache = get_thread_regcache (current_inferior, 1);
   ctx.tframe = NULL;
@@ -976,17 +1315,29 @@ run_breakpoint_commands (CORE_ADDR where)
 
       /* If one command has a problem, stop digging the hole deeper.  */
       if (err)
-	break;
+	return 0;
     }
+
+  return 1;
 }
 
-/* Return 1 if there is a breakpoint inserted in address WHERE
-   and if its condition, if it exists, is true.  */
+void
+run_breakpoint_commands (CORE_ADDR where)
+{
+  /* Only check code (software or hardware) breakpoints.  If one
+     command has a problem, stop digging the hole deeper.  */
+  if (run_breakpoint_commands_z_type (Z_PACKET_SW_BP, where))
+    run_breakpoint_commands_z_type (Z_PACKET_HW_BP, where);
+}
+
+/* See mem-break.h.  */
 
 int
 gdb_breakpoint_here (CORE_ADDR where)
 {
-  return (find_gdb_breakpoint_at (where) != NULL);
+  /* Only check code (software or hardware) breakpoints.  */
+  return (find_gdb_breakpoint (Z_PACKET_SW_BP, where, -1) != NULL
+	  || find_gdb_breakpoint (Z_PACKET_HW_BP, where, -1) != NULL);
 }
 
 void
@@ -1026,29 +1377,26 @@ delete_reinsert_breakpoints (void)
 static void
 uninsert_raw_breakpoint (struct raw_breakpoint *bp)
 {
-  if (bp->inserted)
+  if (bp->inserted < 0)
+    {
+      if (debug_threads)
+	debug_printf ("Breakpoint at %s is marked insert-disabled.\n",
+		      paddress (bp->pc));
+    }
+  else if (bp->inserted > 0)
     {
       int err;
-      unsigned char buf[MAX_BREAKPOINT_LEN];
 
       bp->inserted = 0;
-      /* Since there can be fast tracepoint jumps inserted in the same
-	 address range, we use `write_inferior_memory', which takes
-	 care of layering breakpoints on top of fast tracepoints, and
-	 on top of the buffer we pass it.  This works because we've
-	 already unlinked the fast tracepoint jump above.  Also note
-	 that we need to pass the current shadow contents, because
-	 write_inferior_memory updates any shadow memory with what we
-	 pass here, and we want that to be a nop.  */
-      memcpy (buf, bp->old_data, breakpoint_len);
-      err = write_inferior_memory (bp->pc, buf, breakpoint_len);
+
+      err = the_target->remove_point (bp->raw_type, bp->pc, bp->size, bp);
       if (err != 0)
 	{
 	  bp->inserted = 1;
 
 	  if (debug_threads)
-	    debug_printf ("Failed to uninsert raw breakpoint at 0x%s (%s).\n",
-			  paddress (bp->pc), strerror (err));
+	    debug_printf ("Failed to uninsert raw breakpoint at 0x%s.\n",
+			  paddress (bp->pc));
 	}
     }
 }
@@ -1056,10 +1404,22 @@ uninsert_raw_breakpoint (struct raw_breakpoint *bp)
 void
 uninsert_breakpoints_at (CORE_ADDR pc)
 {
+  struct process_info *proc = current_process ();
   struct raw_breakpoint *bp;
+  int found = 0;
 
-  bp = find_raw_breakpoint_at (pc);
-  if (bp == NULL)
+  for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+    if ((bp->raw_type == raw_bkpt_type_sw
+	 || bp->raw_type == raw_bkpt_type_hw)
+	&& bp->pc == pc)
+      {
+	found = 1;
+
+	if (bp->inserted)
+	  uninsert_raw_breakpoint (bp);
+      }
+
+  if (!found)
     {
       /* This can happen when we remove all breakpoints while handling
 	 a step-over.  */
@@ -1067,11 +1427,7 @@ uninsert_breakpoints_at (CORE_ADDR pc)
 	debug_printf ("Could not find breakpoint at 0x%s "
 		      "in list (uninserting).\n",
 		      paddress (pc));
-      return;
     }
-
-  if (bp->inserted)
-    uninsert_raw_breakpoint (bp);
 }
 
 void
@@ -1081,7 +1437,9 @@ uninsert_all_breakpoints (void)
   struct raw_breakpoint *bp;
 
   for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
-    if (bp->inserted)
+    if ((bp->raw_type == raw_bkpt_type_sw
+	 || bp->raw_type == raw_bkpt_type_hw)
+	&& bp->inserted)
       uninsert_raw_breakpoint (bp);
 }
 
@@ -1093,22 +1451,32 @@ reinsert_raw_breakpoint (struct raw_breakpoint *bp)
   if (bp->inserted)
     error ("Breakpoint already inserted at reinsert time.");
 
-  err = (*the_target->write_memory) (bp->pc, breakpoint_data,
-				     breakpoint_len);
+  err = the_target->insert_point (bp->raw_type, bp->pc, bp->size, bp);
   if (err == 0)
     bp->inserted = 1;
   else if (debug_threads)
-    debug_printf ("Failed to reinsert breakpoint at 0x%s (%s).\n",
-		  paddress (bp->pc), strerror (err));
+    debug_printf ("Failed to reinsert breakpoint at 0x%s (%d).\n",
+		  paddress (bp->pc), err);
 }
 
 void
 reinsert_breakpoints_at (CORE_ADDR pc)
 {
+  struct process_info *proc = current_process ();
   struct raw_breakpoint *bp;
+  int found = 0;
 
-  bp = find_raw_breakpoint_at (pc);
-  if (bp == NULL)
+  for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+    if ((bp->raw_type == raw_bkpt_type_sw
+	 || bp->raw_type == raw_bkpt_type_hw)
+	&& bp->pc == pc)
+      {
+	found = 1;
+
+	reinsert_raw_breakpoint (bp);
+      }
+
+  if (!found)
     {
       /* This can happen when we remove all breakpoints while handling
 	 a step-over.  */
@@ -1116,10 +1484,7 @@ reinsert_breakpoints_at (CORE_ADDR pc)
 	debug_printf ("Could not find raw breakpoint at 0x%s "
 		      "in list (reinserting).\n",
 		      paddress (pc));
-      return;
     }
-
-  reinsert_raw_breakpoint (bp);
 }
 
 void
@@ -1129,7 +1494,9 @@ reinsert_all_breakpoints (void)
   struct raw_breakpoint *bp;
 
   for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
-    if (!bp->inserted)
+    if ((bp->raw_type == raw_bkpt_type_sw
+	 || bp->raw_type == raw_bkpt_type_hw)
+	&& !bp->inserted)
       reinsert_raw_breakpoint (bp);
 }
 
@@ -1144,9 +1511,13 @@ check_breakpoints (CORE_ADDR stop_pc)
 
   while (bp)
     {
-      if (bp->raw->pc == stop_pc)
+      struct raw_breakpoint *raw = bp->raw;
+
+      if ((raw->raw_type == raw_bkpt_type_sw
+	   || raw->raw_type == raw_bkpt_type_hw)
+	  && raw->pc == stop_pc)
 	{
-	  if (!bp->raw->inserted)
+	  if (!raw->inserted)
 	    {
 	      warning ("Hit a removed breakpoint?");
 	      return;
@@ -1178,17 +1549,32 @@ set_breakpoint_data (const unsigned char *bp_data, int bp_len)
 int
 breakpoint_here (CORE_ADDR addr)
 {
-  return (find_raw_breakpoint_at (addr) != NULL);
+  struct process_info *proc = current_process ();
+  struct raw_breakpoint *bp;
+
+  for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+    if ((bp->raw_type == raw_bkpt_type_sw
+	 || bp->raw_type == raw_bkpt_type_hw)
+	&& bp->pc == addr)
+      return 1;
+
+  return 0;
 }
 
 int
 breakpoint_inserted_here (CORE_ADDR addr)
 {
+  struct process_info *proc = current_process ();
   struct raw_breakpoint *bp;
 
-  bp = find_raw_breakpoint_at (addr);
+  for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+    if ((bp->raw_type == raw_bkpt_type_sw
+	 || bp->raw_type == raw_bkpt_type_hw)
+	&& bp->pc == addr
+	&& bp->inserted)
+      return 1;
 
-  return (bp != NULL && bp->inserted);
+  return 0;
 }
 
 static int
@@ -1198,14 +1584,14 @@ validate_inserted_breakpoint (struct raw_breakpoint *bp)
   int err;
 
   gdb_assert (bp->inserted);
+  gdb_assert (bp->raw_type == raw_bkpt_type_sw);
 
   buf = alloca (breakpoint_len);
   err = (*the_target->read_memory) (bp->pc, buf, breakpoint_len);
   if (err || memcmp (buf, breakpoint_data, breakpoint_len) != 0)
     {
       /* Tag it as gone.  */
-      bp->inserted = 0;
-      bp->shlib_disabled = 1;
+      bp->inserted = -1;
       return 0;
     }
 
@@ -1221,7 +1607,7 @@ delete_disabled_breakpoints (void)
   for (bp = proc->breakpoints; bp != NULL; bp = next)
     {
       next = bp->next;
-      if (bp->raw->shlib_disabled)
+      if (bp->raw->inserted < 0)
 	delete_breakpoint_1 (proc, bp);
     }
 }
@@ -1241,8 +1627,10 @@ validate_breakpoints (void)
 
   for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
     {
-      if (bp->raw->inserted)
-	validate_inserted_breakpoint (bp->raw);
+      struct raw_breakpoint *raw = bp->raw;
+
+      if (raw->raw_type == raw_bkpt_type_sw && raw->inserted > 0)
+	validate_inserted_breakpoint (raw);
     }
 
   delete_disabled_breakpoints ();
@@ -1295,6 +1683,9 @@ check_mem_read (CORE_ADDR mem_addr, unsigned char *buf, int mem_len)
       CORE_ADDR start, end;
       int copy_offset, copy_len, buf_offset;
 
+      if (bp->raw_type != raw_bkpt_type_sw)
+	continue;
+
       gdb_assert (bp->old_data >= buf + mem_len
 		  || buf >= &bp->old_data[sizeof (bp->old_data)]);
 
@@ -1315,7 +1706,7 @@ check_mem_read (CORE_ADDR mem_addr, unsigned char *buf, int mem_len)
       copy_offset = start - bp->pc;
       buf_offset = start - mem_addr;
 
-      if (bp->inserted)
+      if (bp->inserted > 0)
 	{
 	  if (validate_inserted_breakpoint (bp))
 	    memcpy (buf + buf_offset, bp->old_data + copy_offset, copy_len);
@@ -1381,6 +1772,9 @@ check_mem_write (CORE_ADDR mem_addr, unsigned char *buf,
       CORE_ADDR start, end;
       int copy_offset, copy_len, buf_offset;
 
+      if (bp->raw_type != raw_bkpt_type_sw)
+	continue;
+
       gdb_assert (bp->old_data >= myaddr + mem_len
 		  || myaddr >= &bp->old_data[sizeof (bp->old_data)]);
 
@@ -1402,7 +1796,7 @@ check_mem_write (CORE_ADDR mem_addr, unsigned char *buf,
       buf_offset = start - mem_addr;
 
       memcpy (bp->old_data + copy_offset, myaddr + buf_offset, copy_len);
-      if (bp->inserted)
+      if (bp->inserted > 0)
 	{
 	  if (validate_inserted_breakpoint (bp))
 	    memcpy (buf + buf_offset, breakpoint_data + copy_offset, copy_len);