Refactor and generalize AArch64 watchpoint support in debugserver

Refactor the debugserver watchpiont support in anticipating of
adding support for AArch64 MASK hardware watchpoints to watch
larger regions of memory.  debugserver already had support for
handling a request to watch an unaligned region of memory up
to 8 bytes using Byte Address Select watchpoints - it would split
an unaligned watch request into two aligned doublewords that
could be watched with two hardware watchpoints using the BAS
specification.

This patch generalizes that code for properly aligning, and
possibly splitting, a watchpoint request into two hardware watchpoints
to handle any size request.  And separates out the specifics
about BAS watchpoints into its own method, so a sibling method
for MASK watchpoints can be dropped in next.

Differential Revision: https://reviews.llvm.org/D149040
rdar://108233371

(cherry picked from commit 5679379)

Author: jasonmolenda

lldb/test/API/functionalities/watchpoint/unaligned-spanning-two-dwords/Makefile

@@ -0,0 +1,3 @@
+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/functionalities/watchpoint/unaligned-spanning-two-dwords/TestUnalignedSpanningDwords.py

@@ -0,0 +1,61 @@
+"""
+Watch 4 bytes which spawn two doubleword aligned regions.
+On a target that supports 8 byte watchpoints, this will
+need to be implemented with a hardware watchpoint on both
+doublewords.
+"""
+
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class UnalignedWatchpointTestCase(TestBase):
+
+    def hit_watchpoint_and_continue(self, process, iter_str):
+        process.Continue()
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
+                         iter_str)
+        thread = process.GetSelectedThread()
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonWatchpoint, iter_str)
+        self.assertEqual(thread.GetStopReasonDataCount(), 1, iter_str)
+        wp_num = thread.GetStopReasonDataAtIndex(0)
+        self.assertEqual(wp_num, 1, iter_str)
+
+    NO_DEBUG_INFO_TESTCASE = True
+    # debugserver on AArch64 has this feature.
+    @skipIf(archs=no_match(['x86_64', 'arm64', 'arm64e', 'aarch64']))
+    @skipUnlessDarwin
+    # debugserver only started returning an exception address within
+    # a range lldb expects in https://reviews.llvm.org/D147820 2023-04-12.
+    # older debugservers will return the base address of the doubleword
+    # which lldb doesn't understand, and will stop executing without a
+    # proper stop reason.
+    @skipIfOutOfTreeDebugserver
+
+    def test_unaligned_watchpoint(self):
+        """Test a watchpoint that is handled by two hardware watchpoint registers."""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+             "break here", self.main_source_file)
+
+        frame = thread.GetFrameAtIndex(0)
+
+        a_bytebuf_6 = frame.GetValueForVariablePath("a.bytebuf[6]")
+        a_bytebuf_6_addr = a_bytebuf_6.GetAddress().GetLoadAddress(target)
+        err = lldb.SBError()
+        wp = target.WatchAddress(a_bytebuf_6_addr, 4, False, True, err)
+        self.assertTrue(err.Success())
+        self.assertTrue(wp.IsEnabled())
+        self.assertEqual(wp.GetWatchSize(), 4)
+        self.assertGreater(wp.GetWatchAddress() % 8, 4, "watched region spans two doublewords")
+
+        # We will hit our watchpoint 6 times during the execution
+        # of the inferior.  If the remote stub does not actually split
+        # the watched region into two doubleword watchpoints, we will 
+        # exit before we get to 6 watchpoint hits.
+        for i in range(1, 7):
+            self.hit_watchpoint_and_continue(process, "wp hit number %s" % i)

lldb/test/API/functionalities/watchpoint/unaligned-spanning-two-dwords/main.c

@@ -0,0 +1,17 @@
+#include <stdint.h>
+#include <stdio.h>
+int main() {
+  union {
+    uint8_t bytebuf[16];
+    uint16_t shortbuf[8];
+    uint64_t dwordbuf[2];
+  } a;
+  a.dwordbuf[0] = a.dwordbuf[1] = 0;
+  a.bytebuf[0] = 0; // break here
+  for (int i = 0; i < 8; i++) {
+    a.shortbuf[i] += i;
+  }
+  for (int i = 0; i < 8; i++) {
+    a.shortbuf[i] += i;
+  }
+}