From FEDORA_PATCHES Mon Sep 17 00:00:00 2001

From: Pedro Franco de Carvalho <pedromfc@linux.ibm.com>

Date: Wed, 7 Jul 2021 18:49:42 -0400

Subject: gdb-rhbz1854784-powerpc-remove-region-limit-dawr-4of7.patch

;; Backport "[PowerPC] Fix debug register issues in ppc-linux-nat"

;; (Pedro Franco de Carvalho, RH BZ 1854784)

This patch fixes some issues with debug register handling for the powerpc

linux native target.

Currently, the target methods for installing and removing hardware

breakpoints and watchpoints in ppc-linux-nat.c affect all threads known to

linux-nat, including threads of different processes.

This patch changes ppc-linux-nat.c so that only the process of

inferior_ptid is affected by these target methods, as GDB expects.

This is done in the same way as various other architectures.  The

install/remove target methods only register a hardware breakpoint or

watchpoint, and then send a stop signal to the threads.  The debug

registers are only changed with ptrace right before each thread is next

resumed, using low_prepare_to_resume.

There are two interfaces to modify debug registers for linux running on

powerpc, with different sets of ptrace requests:

- PPC_PTRACE_GETHWDBGINFO, PPC_PTRACE_SETHWDEBUG, and

  PPC_PTRACE_DELHWDEBUG.

   Or

- PTRACE_SET_DEBUGREG and PTRACE_GET_DEBUGREG

The first set (HWDEBUG) is the more flexible one and allows setting

watchpoints with a variable watched region length and, for certain

embedded processors, multiple types of debug registers (e.g. hardware

breakpoints and hardware-assisted conditions for watchpoints).

Currently, server processors only provide one watchpoint.  The second one

(DEBUGREG) only allows setting one debug register, a watchpoint, so we

only use it if the first one is not available.

The HWDEBUG interface handles debug registers with slot numbers.  Once a

hardware watchpoint or breakpoint is installed (with

PPC_PTRACE_SETHWDEBUG), ptrace returns a slot number.  This slot number

can then be used to remove the watchpoint or breakpoint from the inferior

(with PPC_PTRACE_DELHWDEBUG).  The first interface also provides a

bitmask of available debug register features, which can be obtained with

PPC_PTRACE_GETHWDBGINFO.

When GDB first tries to use debug registers, we try the first interface

with a ptrace call, and if it isn't available, we fall back to the second

one, if available.  We use EIO as an indicator that an interface is not

available in the kernel.  For simplicity, with any other error we

immediately assume no interface is available.  Unfortunately this means

that if a process is killed by a signal right before we try to detect the

interface, we might get an ESRCH, which would prevent debug registers to

be used in the GDB session.  However, it isn't clear that we can safely

raise an exception and try again in the future in all the contexts where

we try to detect the interface.

If the HWDEBUG interface works but provides no feature bits, the target

falls back to the DEBUGREG interface.  When the kernel is configured

without CONFIG_HW_BREAKPOINTS (selected by CONFIG_PERF_EVENTS), there is

a bug that causes watchpoints installed with the HWDEBUG interface not to

trigger.  When this is the case, the feature bits will be zero, which is

used as the indicator to fall back to the DEBUGREG interface.  This isn't

ideal, but has always been the behavior of GDB before this patch, so I

decided not to change it.

A flag indicates for each thread if its debug registers need to be

updated the next time it is resumed.  The flag is set whenever the upper

layers request or remove a hardware watchpoint or breakpoint, or when a

new thread is detected.  Because some kernel configurations disable

watchpoints after they are hit, we also use the last stop reason of the

LWP to determine whether we should update the debug registers.  It isn't

clear that this is also true of BookE hardware breakpoints, but we also

check their stop reason to be on the safe side, since it doesn't hurt.

A map from process numbers to hardware watchpoint or breakpoint objects

keeps track of what has been requested by the upper layers of GDB, since

for GDB installing a hardware watchpoint or breakpoint means doing so for

the whole process.

When using the HWDEBUG interface we also have to keep track of which

slots were last installed in each thread with a map from threads to the

slots, so that they can be removed when needed.  When resuming a thread,

we remove all the slots using this map, then we install all the hardware

watchpoints and breakpoints from the per-process map of requests, and

then update the per-thread map accordingly.

This per-thread state is also used for copying the debug register state

after a fork or a clone is detected.  The kernel might do this depending

on the configuration.  Recent kernels running on server processors that

were configured with CONFIG_PERF_EVENTS (and therefore

CONFIG_HW_BREAKPOINTS) don't copy debug registers across forks and

clones.  Recent kernels without CONFIG_HW_BREAKPOINTS copy this state.  I

believe that on embedded processors (e.g. a ppc440) the debug register

state is copied, but I haven't been able to test this.  To handle both

cases, the per-thread state is always copied when forks and clones are

detected, and when we resume the thread and delete the debug register

slots before updating them, we ignore ENOENT errors.

We don't need to handle this when using the DEBUGREG interface since it

only allows one hardware watchpoint and doesn't return slot numbers, we

just set or clear this watchpoint when needed.

Since we signal running threads to stop after a request is processed, so

that we can update their debug registers when they are next resumed,

there will be a time between signalling the threads and their stop during

which the debug registers haven't been updated, even if the target

methods completed.

The tests in gdb.threads/watchpoint-fork.exp no longer fail with this

patch.

gdb/ChangeLog:

2020-03-30  Pedro Franco de Carvalho  <pedromfc@linux.ibm.com>

	* ppc-linux-nat.c: Include <algorithm>, <unordered_map>, and

	<list>.  Remove inclusion of observable.h.

	(PPC_DEBUG_CURRENT_VERSION): Move up define.

	(struct arch_lwp_info): New struct.

	(class ppc_linux_dreg_interface): New class.

	(struct ppc_linux_process_info): New struct.

	(struct ppc_linux_nat_target) <low_delete_thread, low_new_fork>

	<low_new_clone, low_forget_process, low_prepare_to_resume>

	<copy_thread_dreg_state, mark_thread_stale>

	<mark_debug_registers_changed, register_hw_breakpoint>

	<clear_hw_breakpoint, register_wp, clear_wp>

	<can_use_watchpoint_cond_accel, calculate_dvc, check_condition>

	<num_memory_accesses, get_trigger_type>

	<create_watchpoint_request, hwdebug_point_cmp>

	<init_arch_lwp_info, get_arch_lwp_info>

	<low_stopped_by_watchpoint, low_stopped_data_address>: Declare as

	methods.

	<struct ptid_hash>: New inner struct.

	<m_dreg_interface, m_process_info, m_installed_hw_bps>: Declare

	members.

	(saved_dabr_value, hwdebug_info, max_slots_number)

	(struct hw_break_tuple, struct thread_points, ppc_threads)

	(have_ptrace_hwdebug_interface)

	(hwdebug_find_thread_points_by_tid)

	(hwdebug_insert_point, hwdebug_remove_point): Remove.

	(ppc_linux_nat_target::can_use_hw_breakpoint): Use

	m_dreg_interface, remove call to PTRACE_SET_DEBUGREG.

	(ppc_linux_nat_target::region_ok_for_hw_watchpoint): Add comment,

	use m_dreg_interface.

	(hwdebug_point_cmp): Change to...

	(ppc_linux_nat_target::hwdebug_point_cmp): ...this method.  Use

	reference arguments instead of pointers.

	(ppc_linux_nat_target::ranged_break_num_registers): Use

	m_dreg_interface.

	(ppc_linux_nat_target::insert_hw_breakpoint): Add comment, use

	m_dreg_interface.  Call register_hw_breakpoint.

	(ppc_linux_nat_target::remove_hw_breakpoint): Add comment, use

	m_dreg_interface.  Call clear_hw_breakpoint.

	(get_trigger_type): Change to...

	(ppc_linux_nat_target::get_trigger_type): ...this method.  Add

	comment.

	(ppc_linux_nat_target::insert_mask_watchpoint): Update comment,

	use m_dreg_interface.  Call register_hw_breakpoint.

	(ppc_linux_nat_target::remove_mask_watchpoint): Update comment,

	use m_dreg_interface.  Call clear_hw_breakpoint.

	(can_use_watchpoint_cond_accel): Change to...

	(ppc_linux_nat_target::can_use_watchpoint_cond_accel): ...this

	method.  Update comment, use m_dreg_interface and

	m_process_info.

	(calculate_dvc): Change to...

	(ppc_linux_nat_target::calculate_dvc): ...this method.  Use

	m_dreg_interface.

	(num_memory_accesses): Change to...

	(ppc_linux_nat_target::num_memory_accesses): ...this method.

	(check_condition): Change to...

	(ppc_linux_nat_target::check_condition): ...this method.

	(ppc_linux_nat_target::can_accel_watchpoint_condition): Update

	comment, use m_dreg_interface.

	(create_watchpoint_request): Change to...

	(ppc_linux_nat_target::create_watchpoint_request): ...this

	method.  Use m_dreg_interface.

	(ppc_linux_nat_target::insert_watchpoint): Add comment, use

	m_dreg_interface.  Call register_hw_breakpoint or register_wp.

	(ppc_linux_nat_target::remove_watchpoint): Add comment, use

	m_dreg_interface.  Call clear_hw_breakpoint or clear_wp.

	(ppc_linux_nat_target::low_forget_process)

	(ppc_linux_nat_target::low_new_fork)

	(ppc_linux_nat_target::low_new_clone)

	(ppc_linux_nat_target::low_delete_thread)

	(ppc_linux_nat_target::low_prepare_to_resume): New methods.

	(ppc_linux_nat_target::low_new_thread): Remove previous logic,

	only call mark_thread_stale.

	(ppc_linux_thread_exit): Remove.

	(ppc_linux_nat_target::stopped_data_address): Change to...

	(ppc_linux_nat_target::low_stopped_data_address): This. Add

	comment, use m_dreg_interface and m_thread_hw_breakpoints.

	(ppc_linux_nat_target::stopped_by_watchpoint): Change to...

	(ppc_linux_nat_target::stopped_by_watchpoint): This.  Add

	comment.  Call low_stopped_data_address.

	(ppc_linux_nat_target::watchpoint_addr_within_range): Use

	m_dreg_interface.

	(ppc_linux_nat_target::masked_watch_num_registers): Use

	m_dreg_interface.

	(ppc_linux_nat_target::copy_thread_dreg_state)

	(ppc_linux_nat_target::mark_thread_stale)

	(ppc_linux_nat_target::mark_debug_registers_changed)

	(ppc_linux_nat_target::register_hw_breakpoint)

	(ppc_linux_nat_target::clear_hw_breakpoint)

	(ppc_linux_nat_target::register_wp)

	(ppc_linux_nat_target::clear_wp)

	(ppc_linux_nat_target::init_arch_lwp_info)

	(ppc_linux_nat_target::get_arch_lwp_info): New methods.

	(_initialize_ppc_linux_nat): Remove observer callback.

diff --git a/gdb/aarch64-linux-nat.c b/gdb/aarch64-linux-nat.c

--- a/gdb/aarch64-linux-nat.c

+++ b/gdb/aarch64-linux-nat.c

@@ -64,14 +64,14 @@ public:

   int can_use_hw_breakpoint (enum bptype, int, int) override;

   int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;

   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;

-  int region_ok_for_hw_watchpoint (CORE_ADDR, LONGEST) override;

+  int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;

   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,

 			 struct expression *) override;

   int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,

 			 struct expression *) override;

   bool stopped_by_watchpoint () override;

   bool stopped_data_address (CORE_ADDR *) override;

-  bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, LONGEST) override;

+  bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;

   int can_do_single_step () override;

@@ -808,7 +808,7 @@ aarch64_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len,

 /* Implement the "region_ok_for_hw_watchpoint" target_ops method.  */

 int

-aarch64_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)

+aarch64_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)

 {

   return aarch64_linux_region_ok_for_watchpoint (addr, len);

 }

@@ -888,7 +888,7 @@ aarch64_linux_nat_target::stopped_by_watchpoint ()

 bool

 aarch64_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr,

 							CORE_ADDR start,

-							LONGEST length)

+							int length)

 {

   return start <= addr && start + length - 1 >= addr;

 }

diff --git a/gdb/arm-linux-nat.c b/gdb/arm-linux-nat.c

--- a/gdb/arm-linux-nat.c

+++ b/gdb/arm-linux-nat.c

@@ -80,7 +80,7 @@ public:

   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;

-  int region_ok_for_hw_watchpoint (CORE_ADDR, LONGEST) override;

+  int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;

   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,

 			 struct expression *) override;

@@ -91,7 +91,7 @@ public:

   bool stopped_data_address (CORE_ADDR *) override;

-  bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, LONGEST) override;

+  bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;

   const struct target_desc *read_description () override;

@@ -1093,7 +1093,7 @@ arm_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch,

 /* Are we able to use a hardware watchpoint for the LEN bytes starting at 

    ADDR?  */

 int

-arm_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)

+arm_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)

 {

   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();

   CORE_ADDR max_wp_length, aligned_addr;

@@ -1202,7 +1202,7 @@ arm_linux_nat_target::stopped_by_watchpoint ()

 bool

 arm_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr,

 						    CORE_ADDR start,

-						    LONGEST length)

+						    int length)

 {

   return start <= addr && start + length - 1 >= addr;

 }

diff --git a/gdb/mips-linux-nat.c b/gdb/mips-linux-nat.c

--- a/gdb/mips-linux-nat.c

+++ b/gdb/mips-linux-nat.c

@@ -614,7 +614,7 @@ mips_linux_nat_target::stopped_data_address (CORE_ADDR *paddr)

    the specified region can be covered by the watch registers.  */

 int

-mips_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, LONGEST len)

+mips_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)

 {

   struct pt_watch_regs dummy_regs;

   int i;

diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c

--- a/gdb/ppc-linux-nat.c

+++ b/gdb/ppc-linux-nat.c

@@ -18,7 +18,6 @@

    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 #include "defs.h"

-#include "observable.h"

 #include "frame.h"

 #include "inferior.h"

 #include "gdbthread.h"

@@ -37,6 +36,9 @@

 #include <sys/procfs.h>

 #include "nat/gdb_ptrace.h"

 #include "inf-ptrace.h"

+#include <algorithm>

+#include <unordered_map>

+#include <list>

 /* Prototypes for supply_gregset etc.  */

 #include "gregset.h"

@@ -52,6 +54,13 @@

 #include "nat/ppc-linux.h"

 #include "linux-tdep.h"

+/* Function type for the CALLBACK argument of iterate_over_lwps_new.  */

+typedef int (iterate_over_lwps_new_ftype) (struct lwp_info *lwp);

+

+static struct lwp_info *iterate_over_lwps_new

+    (ptid_t filter,

+     gdb::function_view<iterate_over_lwps_new_ftype> callback);

+

 /* Similarly for the hardware watchpoint support.  These requests are used

    when the PowerPC HWDEBUG ptrace interface is not available.  */

 #ifndef PTRACE_GET_DEBUGREG

@@ -135,6 +144,10 @@ struct ppc_hw_breakpoint

 #define PPC_DEBUG_FEATURE_DATA_BP_DAWR	0x10

 #endif /* PPC_DEBUG_FEATURE_DATA_BP_DAWR */

+/* The version of the PowerPC HWDEBUG kernel interface that we will use, if

+   available.  */

+#define PPC_DEBUG_CURRENT_VERSION 1

+

 /* Similarly for the general-purpose (gp0 -- gp31)

    and floating-point registers (fp0 -- fp31).  */

 #ifndef PTRACE_GETREGS

@@ -269,6 +282,214 @@ int have_ptrace_getsetregs = 1;

    them and gotten an error.  */

 int have_ptrace_getsetfpregs = 1;

+/* Private arch info associated with each thread lwp_info object, used

+   for debug register handling.  */

+

+struct arch_lwp_info

+{

+  /* When true, indicates that the debug registers installed in the

+     thread no longer correspond to the watchpoints and breakpoints

+     requested by GDB.  */

+  bool debug_regs_stale;

+

+  /* We need a back-reference to the PTID of the thread so that we can

+     cleanup the debug register state of the thread in

+     low_delete_thread.  */

+  ptid_t lwp_ptid;

+};

+

+/* Class used to detect which set of ptrace requests that

+   ppc_linux_nat_target will use to install and remove hardware

+   breakpoints and watchpoints.

+

+   The interface is only detected once, testing the ptrace calls.  The

+   result can indicate that no interface is available.

+

+   The Linux kernel provides two different sets of ptrace requests to

+   handle hardware watchpoints and breakpoints for Power:

+

+   - PPC_PTRACE_GETHWDBGINFO, PPC_PTRACE_SETHWDEBUG, and

+     PPC_PTRACE_DELHWDEBUG.

+

+   Or

+

+   - PTRACE_SET_DEBUGREG and PTRACE_GET_DEBUGREG

+

+   The first set is the more flexible one and allows setting watchpoints

+   with a variable watched region length and, for BookE processors,

+   multiple types of debug registers (e.g. hardware breakpoints and

+   hardware-assisted conditions for watchpoints).  The second one only

+   allows setting one debug register, a watchpoint, so we only use it if

+   the first one is not available.  */

+

+class ppc_linux_dreg_interface

+{

+public:

+

+  ppc_linux_dreg_interface ()

+    : m_interface (), m_hwdebug_info ()

+  {

+  };

+

+  DISABLE_COPY_AND_ASSIGN (ppc_linux_dreg_interface);

+

+  /* One and only one of these three functions returns true, indicating

+     whether the corresponding interface is the one we detected.  The

+     interface must already have been detected as a precontidion.  */

+

+  bool hwdebug_p ()

+  {

+    gdb_assert (detected_p ());

+    return *m_interface == HWDEBUG;

+  }

+

+  bool debugreg_p ()

+  {

+    gdb_assert (detected_p ());

+    return *m_interface == DEBUGREG;

+  }

+

+  bool unavailable_p ()

+  {

+    gdb_assert (detected_p ());

+    return *m_interface == UNAVAILABLE;

+  }

+

+  /* Returns the debug register capabilities of the target.  Should only

+     be called if the interface is HWDEBUG.  */

+  const struct ppc_debug_info &hwdebug_info ()

+  {

+    gdb_assert (hwdebug_p ());

+

+    return m_hwdebug_info;

+  }

+

+  /* Returns true if the interface has already been detected.  This is

+     useful for cases when we know there is no work to be done if the

+     interface hasn't been detected yet.  */

+  bool detected_p ()

+  {

+    return m_interface.has_value ();

+  }

+

+  /* Detect the available interface, if any, if it hasn't been detected

+     before, using PTID for the necessary ptrace calls.  */

+

+  void detect (const ptid_t &ptid)

+  {

+    if (m_interface.has_value ())

+      return;

+

+    gdb_assert (ptid.lwp_p ());

+

+    bool no_features = false;

+

+    if (ptrace (PPC_PTRACE_GETHWDBGINFO, ptid.lwp (), 0, &m_hwdebug_info)

+	!= -1)

+      {

+	/* If there are no advertised features, we don't use the

+	   HWDEBUG interface and try the DEBUGREG interface instead.

+	   It shouldn't be necessary to do this, however, when the

+	   kernel is configured without CONFIG_HW_BREAKPOINTS (selected

+	   by CONFIG_PERF_EVENTS), there is a bug that causes

+	   watchpoints installed with the HWDEBUG interface not to

+	   trigger.  When this is the case, features will be zero,

+	   which we use as an indicator to fall back to the DEBUGREG

+	   interface.  */

+	if (m_hwdebug_info.features != 0)

+	  {

+	    m_interface.emplace (HWDEBUG);

+	    return;

+	  }

+	else

+	  no_features = true;

+      }

+

+    /* EIO indicates that the request is invalid, so we try DEBUGREG

+       next.  Technically, it can also indicate other failures, but we

+       can't differentiate those.

+

+       Other errors could happen for various reasons.  We could get an

+       ESRCH if the traced thread was killed by a signal.  Trying to

+       detect the interface with another thread in the future would be

+       complicated, as callers would have to handle an "unknown

+       interface" case.  It's also unclear if raising an exception

+       here would be safe.

+

+       Other errors, such as ENODEV, could be more permanent and cause

+       a failure for any thread.

+

+       For simplicity, with all errors other than EIO, we set the

+       interface to UNAVAILABLE and don't try DEBUGREG.  If DEBUGREG

+       fails too, we'll also set the interface to UNAVAILABLE.  It's

+       unlikely that trying the DEBUGREG interface with this same thread

+       would work, for errors other than EIO.  This means that these

+       errors will cause hardware watchpoints and breakpoints to become

+       unavailable throughout a GDB session.  */

+

+    if (no_features || errno == EIO)

+      {

+	unsigned long wp;

+

+	if (ptrace (PTRACE_GET_DEBUGREG, ptid.lwp (), 0, &wp) != -1)

+	  {

+	    m_interface.emplace (DEBUGREG);

+	    return;

+	  }

+      }

+

+    if (errno != EIO)

+      warning (_("Error when detecting the debug register interface. "

+		 "Debug registers will be unavailable."));

+

+    m_interface.emplace (UNAVAILABLE);

+    return;

+  }

+

+private:

+

+  /* HWDEBUG represents the set of calls PPC_PTRACE_GETHWDBGINFO,

+     PPC_PTRACE_SETHWDEBUG and PPC_PTRACE_DELHWDEBUG.

+

+     DEBUGREG represents the set of calls PTRACE_SET_DEBUGREG and

+     PTRACE_GET_DEBUGREG.

+

+     UNAVAILABLE can indicate that the kernel doesn't support any of the

+     two sets of requests or that there was an error when we tried to

+     detect wich interface is available.  */

+

+  enum debug_reg_interface

+    {

+     UNAVAILABLE,

+     HWDEBUG,

+     DEBUGREG

+    };

+

+  /* The interface option.  Initialized if has_value () returns true.  */

+  gdb::optional<enum debug_reg_interface> m_interface;

+

+  /* The info returned by the kernel with PPC_PTRACE_GETHWDBGINFO.  Only

+     valid if we determined that the interface is HWDEBUG.  */

+  struct ppc_debug_info m_hwdebug_info;

+};

+

+/* Per-process information.  This includes the hardware watchpoints and

+   breakpoints that GDB requested to this target.  */

+

+struct ppc_linux_process_info

+{

+  /* The list of hardware watchpoints and breakpoints that GDB requested

+     for this process.

+

+     Only used when the interface is HWDEBUG.  */

+  std::list<struct ppc_hw_breakpoint> requested_hw_bps;

+

+  /* The watchpoint value that GDB requested for this process.

+

+     Only used when the interface is DEBUGREG.  */

+  gdb::optional<long> requested_wp_val;

+};

+

 struct ppc_linux_nat_target final : public linux_nat_target

 {

   /* Add our register access methods.  */

@@ -284,7 +505,7 @@ struct ppc_linux_nat_target final : public linux_nat_target

   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *)

     override;

-  int region_ok_for_hw_watchpoint (CORE_ADDR, LONGEST) override;

+  int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;

   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,

 			 struct expression *) override;

@@ -298,13 +519,9 @@ struct ppc_linux_nat_target final : public linux_nat_target

   int remove_mask_watchpoint (CORE_ADDR, CORE_ADDR, enum target_hw_bp_type)

     override;

-  bool stopped_by_watchpoint () override;

-

-  bool stopped_data_address (CORE_ADDR *) override;

+  bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;

-  bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, LONGEST) override;

-

-  bool can_accel_watchpoint_condition (CORE_ADDR, LONGEST, int, struct expression *)

+  bool can_accel_watchpoint_condition (CORE_ADDR, int, int, struct expression *)

     override;

   int masked_watch_num_registers (CORE_ADDR, CORE_ADDR) override;

@@ -318,7 +535,95 @@ struct ppc_linux_nat_target final : public linux_nat_target

     override;

   /* Override linux_nat_target low methods.  */

+  bool low_stopped_by_watchpoint () override;

+

+  bool low_stopped_data_address (CORE_ADDR *) override;

+

   void low_new_thread (struct lwp_info *lp) override;

+

+  void low_delete_thread (arch_lwp_info *) override;

+

+  void low_new_fork (struct lwp_info *, pid_t) override;

+

+  void low_new_clone (struct lwp_info *, pid_t) override;

+

+  void low_forget_process (pid_t pid) override;

+

+  void low_prepare_to_resume (struct lwp_info *) override;

+

+private:

+

+  void copy_thread_dreg_state (const ptid_t &parent_ptid,

+			       const ptid_t &child_ptid);

+

+  void mark_thread_stale (struct lwp_info *lp);

+

+  void mark_debug_registers_changed (pid_t pid);

+

+  void register_hw_breakpoint (pid_t pid,

+			       const struct ppc_hw_breakpoint &bp);

+

+  void clear_hw_breakpoint (pid_t pid,

+			    const struct ppc_hw_breakpoint &a);

+

+  void register_wp (pid_t pid, long wp_value);

+

+  void clear_wp (pid_t pid);

+

+  bool can_use_watchpoint_cond_accel (void);

+

+  void calculate_dvc (CORE_ADDR addr, int len,

+		      CORE_ADDR data_value,

+		      uint32_t *condition_mode,

+		      uint64_t *condition_value);

+

+  int check_condition (CORE_ADDR watch_addr,

+		       struct expression *cond,

+		       CORE_ADDR *data_value, int *len);

+

+  int num_memory_accesses (const std::vector<value_ref_ptr> &chain);

+

+  int get_trigger_type (enum target_hw_bp_type type);

+

+  void create_watchpoint_request (struct ppc_hw_breakpoint *p,

+				  CORE_ADDR addr,

+				  int len,

+				  enum target_hw_bp_type type,

+				  struct expression *cond,

+				  int insert);

+

+  bool hwdebug_point_cmp (const struct ppc_hw_breakpoint &a,

+			  const struct ppc_hw_breakpoint &b);

+

+  void init_arch_lwp_info (struct lwp_info *lp);

+

+  arch_lwp_info *get_arch_lwp_info (struct lwp_info *lp);

+

+  /* The ptrace interface we'll use to install hardware watchpoints and

+     breakpoints (debug registers).  */

+  ppc_linux_dreg_interface m_dreg_interface;

+

+  /* A map from pids to structs containing info specific to each

+     process.  */

+  std::unordered_map<pid_t, ppc_linux_process_info> m_process_info;

+

+  /* Callable object to hash ptids by their lwp number.  */

+  struct ptid_hash

+  {

+    std::size_t operator() (const ptid_t &ptid) const

+    {

+      return std::hash<long>{} (ptid.lwp ());

+    }

+  };

+

+  /* A map from ptid_t objects to a list of pairs of slots and hardware

+     breakpoint objects.  This keeps track of which hardware breakpoints

+     and watchpoints were last installed in each slot of each thread.

+

+     Only used when the interface is HWDEBUG.  */

+  std::unordered_map 

+		      std::list<std::pair<long, ppc_hw_breakpoint>>,

+		      ptid_hash> m_installed_hw_bps;

 };

 static ppc_linux_nat_target the_ppc_linux_nat_target;

@@ -1725,102 +2030,50 @@ ppc_linux_nat_target::read_description ()

   return ppc_linux_match_description (features);

 }

-/* The cached DABR value, to install in new threads.

-   This variable is used when the PowerPC HWDEBUG ptrace

-   interface is not available.  */

-static long saved_dabr_value;

-

-/* Global structure that will store information about the available

-   features provided by the PowerPC HWDEBUG ptrace interface.  */

-static struct ppc_debug_info hwdebug_info;

-

-/* Global variable that holds the maximum number of slots that the

-   kernel will use.  This is only used when PowerPC HWDEBUG ptrace interface

-   is available.  */

-static size_t max_slots_number = 0;

-

-struct hw_break_tuple

-{

-  long slot;

-  struct ppc_hw_breakpoint *hw_break;

-};

-

-/* This is an internal VEC created to store information about *points inserted

-   for each thread.  This is used when PowerPC HWDEBUG ptrace interface is

-   available.  */

-typedef struct thread_points

-  {

-    /* The TID to which this *point relates.  */

-    int tid;

-    /* Information about the *point, such as its address, type, etc.

-

-       Each element inside this vector corresponds to a hardware

-       breakpoint or watchpoint in the thread represented by TID.  The maximum