[ppc64le] [lldb] [testsuite] Fix false FAILs on ppc64le with no hw watchpoints

[jankratochvil]

Summary

Hardware watchpoints availability differs between hardware (and it also depends on Linux kernel version).
On POWER9, altivec supported, 2.2 (pvr 004e 1202) the testsuite had 67 FAILs, with this patch it has 23 FAILs (probably no longer watchpoint related).
The problem is UNSUPPORTED keyword can list only a triple and some PowerPC hardware can do hw watchpoints. Therefore I had to implement the UNSUPPORTED category in code.
67 FAILs: https://people.redhat.com/jkratoch/lldb-4b8962940322fe732126ec583013ecb5b6a1112e-ppc64le.log
23 FAILs: https://people.redhat.com/jkratoch/lldb-4b8962940322fe732126ec583013ecb5b6a1112e-fix-ppc64le.log

[jankratochvil]

I forgot it should be also checking it is PowerPC.

[DavidSpickett]

Is there any command we can run to directly get the number of h/w watchpoints?

I'm thinking that a lot of these are:

try:
  doThing()
except:
  if we got this specific error

Then you could have this at the start of each test instead:

if not self.HasWatchpoints():
   self.skipTest(...)

Where HasWatchpoints runs that command. If there isn't a specific command you could do something silly like watch main and see if it succeeds then remove the watchpoint.

Failing that you could make some skipIfErrorNoWatchpoints(err) just to reduce the duplication.

lldb/test/API/commands/watchpoints/hello_watchpoint/TestMyFirstWatchpoint.py

68

Is the arch check here needed, also should it include powerpc64be? (not very familiar with powerpc but your title says ppc64*)

I don't think it would harm to not check the arch.

[jankratochvil]

In D102140#2768660, @DavidSpickett wrote:

Is there any command we can run to directly get the number of h/w watchpoints?

Not aware of, I will check and/or code some, thanks for the review.

lldb/test/API/commands/watchpoints/hello_watchpoint/TestMyFirstWatchpoint.py

68

Is the arch check here needed, also should it include powerpc64be? (not very familiar with powerpc but your title says ppc64*)

ppc64be is not supported by LLDB (and I expect it will never be as PowerPC has moved BE->LE).

I don't think it would harm to not check the arch.

I think it would harm. As if there is a regression LLDB falsely reports 0 watchpoints on all arches the testsuite will not find it out. Sure this possible uncaught regression affects also PPC but one cannot do anything with it there.

[DavidSpickett]

lldb/test/API/commands/watchpoints/hello_watchpoint/TestMyFirstWatchpoint.py

68

I think it would harm. As if there is a regression LLDB falsely reports 0 watchpoints on all arches the testsuite will not find it out. Sure this possible uncaught regression affects also PPC but one cannot do anything with it there.

True, I didn't think of it that way.

[DavidSpickett]

If there isn't a specific command you could do something silly like watch main and see if it succeeds then remove the watchpoint.

Or you could watch address 0, there's no requirement for it to be a symbol.

lldb/packages/Python/lldbsuite/test/concurrent_base.py

def do_thread_actions(self,
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Check we are at line self.setup_breakpoint
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=["stop reason = breakpoint 1."])
 
         # Initialize the (single) watchpoint on the global variable (g_watchme)
         if num_watchpoint_threads + num_delay_watchpoint_threads > 0:
+            try:
                 self.runCmd("watchpoint set variable g_watchme")
+            except:
+                if "\nerror: Target supports (0) hardware watchpoint slots.\n" in self.res.GetError():
+                    self.skipTest('Watchpoints are not supported')
+                raise
+
             for w in self.inferior_target.watchpoint_iter():
                 self.thread_watchpoint = w
                 self.assertTrue(
                     "g_watchme" in str(
                         self.thread_watchpoint),
                     "Watchpoint location not shown correctly")
 
         # Get the process

lldb/test/API/commands/watchpoints/hello_watchpoint/TestMyFirstWatchpoint.py

def test_hello_watchpoint_using_watchpoint_set(self):
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for 'global'.
         # There should be only one watchpoint hit (see main.c).
+        try:
             self.expect(
                 "watchpoint set variable -w write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",
                     substrs=['hit_count = 0'])
 
         self.runCmd("process continue")
 

lldb/test/API/commands/watchpoints/multiple_threads/TestWatchpointMultipleThreads.py

def test_watchpoint_after_thread_start(self):
         """Test that we can hit a watchpoint we set after another thread starts"""
         self.do_watchpoint_test("After running the thread")
 
     def do_watchpoint_test(self, line):
         self.build()
         lldbutil.run_to_source_breakpoint(self, line, self.main_spec)
 
         # Now let's set a write-type watchpoint for variable 'g_val'.
+        try:
             self.expect(
                 "watchpoint set variable -w write g_val",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w'])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",
                     substrs=['hit_count = 0'])
 
         self.runCmd("process continue")
 
class WatchpointForMultipleThreadsTestCase(TestBase):
     def test_watchpoint_multiple_threads_wp_set_and_then_delete(self):
         """Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires."""
         self.build()
         self.setTearDownCleanup()
 
         lldbutil.run_to_source_breakpoint(self, "After running the thread", self.main_spec)
 
         # Now let's set a write-type watchpoint for variable 'g_val'.
+        try:
             self.expect(
                 "watchpoint set variable -w write g_val",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w'])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",
                     substrs=['hit_count = 0'])
 
         watchpoint_stops = 0
         while True:

lldb/test/API/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py

def test(self):
         read_value = frame.FindValue('g_watch_me_read',
                                      lldb.eValueTypeVariableGlobal)
         self.assertTrue(read_value.IsValid(), "Failed to find read value.")
 
         error = lldb.SBError()
 
         # resolve_location=True, read=True, write=False
         read_watchpoint = read_value.Watch(True, True, False, error)
+        if not error.Success() and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(error.Success(),
                         "Error while setting watchpoint: %s" %
                         error.GetCString())
         self.assertTrue(read_watchpoint, "Failed to set read watchpoint.")
 
         thread.StepOver()
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)

lldb/test/API/commands/watchpoints/watchpoint_commands/TestWatchpointCommands.py

def test_rw_watchpoint(self):
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a read_write-type watchpoint for 'global'.
         # There should be two watchpoint hits (see main.c).
+        try:
             self.expect(
                 "watchpoint set variable -w read_write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = rw',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",
                     substrs=['Number of supported hardware watchpoints:',
                              'hit_count = 0'])
 
         self.runCmd("process continue")
class WatchpointCommandsTestCase(TestBase):
     def test_rw_watchpoint_delete(self):
         """Test delete watchpoint and expect not to stop for watchpoint."""
         self.build()
         lldbutil.run_to_line_breakpoint(self, lldb.SBFileSpec(self.source),
                                         self.line)
 
         # Now let's set a read_write-type watchpoint for 'global'.
         # There should be two watchpoint hits (see main.c).
+        try:
             self.expect(
                 "watchpoint set variable -w read_write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = rw',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+         and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+             in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Delete the watchpoint immediately, but set auto-confirm to true
         # first.
         self.runCmd("settings set auto-confirm true")
         self.expect("watchpoint delete",
                     substrs=['All watchpoints removed.'])
         # Restore the original setting of auto-confirm.
         self.runCmd("settings clear auto-confirm")
def test_rw_watchpoint_set_ignore_count(self):
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a read_write-type watchpoint for 'global'.
         # There should be two watchpoint hits (see main.c).
+        try:
             self.expect(
                 "watchpoint set variable -w read_write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = rw',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Set the ignore count of the watchpoint immediately.
         self.expect("watchpoint ignore -i 2",
                     substrs=['All watchpoints ignored.'])
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # Expect to find an ignore_count of 2.
         self.expect("watchpoint list -v",
def test_rw_disable_after_first_stop(self):
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a read_write-type watchpoint for 'global'.
         # There should be two watchpoint hits (see main.c).
+        try:
             self.expect(
                 "watchpoint set variable -w read_write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = rw',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",
                     substrs=['state = enabled', 'hit_count = 0'])
 
         self.runCmd("process continue")
 
def test_rw_disable_then_enable(self):
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a read_write-type watchpoint for 'global'.
         # There should be two watchpoint hits (see main.c).
+        try:
             self.expect(
                 "watchpoint set variable -w read_write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = rw',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Immediately, we disable the watchpoint.  We won't be stopping due to a
         # watchpoint after this.
         self.runCmd("watchpoint disable")
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",

lldb/test/API/commands/watchpoints/watchpoint_commands/command/TestWatchpointCommandLLDB.py

def test_watchpoint_command(self):
 
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for 'global'.
+        try:
             self.expect(
                 "watchpoint set variable -w write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         self.runCmd('watchpoint command add 1 -o "expr -- cookie = 777"')
 
         # List the watchpoint command we just added.
         self.expect("watchpoint command list 1",
                     substrs=['expr -- cookie = 777'])
 
         # Use the '-v' option to do verbose listing of the watchpoint.
def test_watchpoint_command_can_disable_a_watchpoint(self):
 
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for 'global'.
+        try:
             self.expect(
                 "watchpoint set variable -w write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         self.runCmd('watchpoint command add 1 -o "watchpoint disable 1"')
 
         # List the watchpoint command we just added.
         self.expect("watchpoint command list 1",
                     substrs=['watchpoint disable 1'])
 
         # Use the '-v' option to do verbose listing of the watchpoint.

lldb/test/API/commands/watchpoints/watchpoint_commands/command/TestWatchpointCommandPython.py

def test_watchpoint_command(self):
 
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for 'global'.
+        try:
             self.expect(
                 "watchpoint set variable -w write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         self.runCmd(
             'watchpoint command add -s python 1 -o \'frame.EvaluateExpression("cookie = 777")\'')
 
         # List the watchpoint command we just added.
         self.expect("watchpoint command list 1",
                     substrs=['frame.EvaluateExpression', 'cookie = 777'])
 
def test_continue_in_watchpoint_command(self):
 
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for 'global'.
+        try:
             self.expect(
                 "watchpoint set variable -w write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         cmd_script_file = os.path.join(self.getSourceDir(),
                                        "watchpoint_command.py")
         self.runCmd("command script import '%s'" % (cmd_script_file))
 
         self.runCmd(
             'watchpoint command add -F watchpoint_command.watchpoint_command')
 

lldb/test/API/commands/watchpoints/watchpoint_commands/condition/TestWatchpointConditionCmd.py

def test_watchpoint_cond(self):
         # We should be stopped again due to the breakpoint.
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for 'global'.
         # With a condition of 'global==5'.
+        try:
             self.expect(
                 "watchpoint set variable -w write global",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 4',
                     'type = w',
                     '%s:%d' %
                     (self.source,
                      self.decl)])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         self.runCmd("watchpoint modify -c 'global==5'")
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",
                     substrs=['global==5', 'hit_count = 0'])
 

lldb/test/API/commands/watchpoints/watchpoint_count/TestWatchpointCount.py

def test_watchpoint_count(self):
         self.build()
         (_, process, thread, _) = lldbutil.run_to_source_breakpoint(self, "patatino", lldb.SBFileSpec("main.c"))
         frame = thread.GetFrameAtIndex(0)
         first_var = frame.FindVariable("x1")
         second_var = frame.FindVariable("x2")
 
         error = lldb.SBError()
         first_watch = first_var.Watch(True, False, True, error)
+        if not error.Success() and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         if not error.Success():
             self.fail(
                 "Failed to make watchpoint for x1: %s" %
                 (error.GetCString()))
 
         second_watch = second_var.Watch(True, False, True, error)
         if not error.Success():
             self.fail(

lldb/test/API/commands/watchpoints/watchpoint_disable/TestWatchpointDisable.py

def do_test(self, test_enable):
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, bkpt_before)
         self.assertTrue(thread.IsValid(), "We didn't stop at the before breakpoint.")
 
         ret_val = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand("watchpoint set variable -w write global_var", ret_val)
+        if not ret_val.Succeeded() and self.getArchitecture() == 'powerpc64le' \
+           and '\nerror: Target supports (0) hardware watchpoint slots.\n' \
+               in ret_val.GetError():
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(ret_val.Succeeded(), "Watchpoint set variable did not return success.")
 
         wp = self.target.FindWatchpointByID(1)
         self.assertTrue(wp.IsValid(), "Didn't make a valid watchpoint.")
         self.assertNotEqual(wp.GetWatchAddress(), lldb.LLDB_INVALID_ADDRESS, "Watch address is invalid")
 
         wp.SetEnabled(False)
         self.assertTrue(not wp.IsEnabled(), "The watchpoint thinks it is still enabled")

lldb/test/API/commands/watchpoints/watchpoint_events/TestWatchpointEvents.py

def test_with_python_api(self):
         self.target_bcast.AddListener(
             self.listener, lldb.SBTarget.eBroadcastBitWatchpointChanged)
         self.listener.StartListeningForEvents(
             self.target_bcast, lldb.SBTarget.eBroadcastBitWatchpointChanged)
 
         error = lldb.SBError()
         local_watch = local_var.Watch(True, False, True, error)
         if not error.Success():
+            if self.getArchitecture() == 'powerpc64le' \
+               and error.GetCString() \
+                   == 'Target supports (0) hardware watchpoint slots.\n':
+                self.skipTest('Watchpoints are not supported')
             self.fail(
                 "Failed to make watchpoint for local_var: %s" %
                 (error.GetCString()))
 
         self.GetWatchpointEvent(lldb.eWatchpointEventTypeAdded)
         # Now change some of the features of this watchpoint and make sure we
         # get events:
         local_watch.SetEnabled(False)

lldb/test/API/commands/watchpoints/watchpoint_on_vectors/TestValueOfVectorVariable.py

def value_of_vector_variable_with_watchpoint_set(self):
 
         # Set break to get a frame
         self.runCmd("b main")
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Value of a vector variable should be displayed correctly
+        try:
             self.expect(
                 "watchpoint set variable global_vector",
                 WATCHPOINT_CREATED,
                 substrs=['new value: (1, 2, 3, 4)'])
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise

lldb/test/API/commands/watchpoints/watchpoint_set_command/TestWatchLocationWithWatchSet.py

def test_watchlocation_using_watchpoint_set(self):
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint pointed to by 'g_char_ptr' and
         # with offset as 7.
         # The main.cpp, by design, misbehaves by not following the agreed upon
         # protocol of only accessing the allowable index range of [0, 6].
+        try:
             self.expect(
                 "watchpoint set expression -w write -s 1 -- g_char_ptr + 7",
                 WATCHPOINT_CREATED,
                 substrs=[
                     'Watchpoint created',
                     'size = 1',
                     'type = w'])
             self.runCmd("expr unsigned val = g_char_ptr[7]; val")
             self.expect(self.res.GetOutput().splitlines()[0], exe=False,
                         endstr=' = 0')
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                self.skipTest('Watchpoints are not supported')
+            raise
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 0 initially.
         self.expect("watchpoint list -v",
                     substrs=['hit_count = 0'])
 
         self.runCmd("process continue")
 

lldb/test/API/commands/watchpoints/watchpoint_size/TestWatchpointSizes.py

def run_watchpoint_size_test(self, arrayName, array_size, watchsize):
         for i in range(array_size):
             # We should be stopped again due to the breakpoint.
             # The stop reason of the thread should be breakpoint.
             self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                         substrs=['stopped', 'stop reason = breakpoint'])
 
             # Set a read_write type watchpoint arrayName
             watch_loc = arrayName + "[" + str(i) + "]"
+            try:
                 self.expect(
                     "watchpoint set variable -w read_write " +
                     watch_loc,
                     WATCHPOINT_CREATED,
                     substrs=[
                         'Watchpoint created',
                         'size = ' +
                         watchsize,
                         'type = rw'])
+            except:
+                if self.getArchitecture() == 'powerpc64le' \
+                   and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                       in self.res.GetError():
+                    self.skipTest('Watchpoints are not supported')
+                raise
 
             # Use the '-v' option to do verbose listing of the watchpoint.
             # The hit count should be 0 initially.
             self.expect("watchpoint list -v", substrs=['hit_count = 0'])
 
             self.runCmd("process continue")
 
             # We should be stopped due to the watchpoint.

lldb/test/API/functionalities/completion/TestCompletion.py

def test_common_complete_watchpoint_ids(self):
         for subcommand in subcommands:
             self.complete_from_to('watchpoint ' + subcommand + ' ',
                                   'watchpoint ' + subcommand + ' ')
 
         # Create a process to provide a target and enable watchpoint setting.
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp"))
 
+        try:
             self.runCmd('watchpoint set variable ptr_fooo')
+        except:
+            if self.getArchitecture() == 'powerpc64le' \
+               and "\nerror: Target supports (0) hardware watchpoint slots.\n" \
+                   in self.res.GetError():
+                return
+            raise
         for subcommand in subcommands:
             self.complete_from_to('watchpoint ' + subcommand + ' ', ['1'])
 
     def test_settings_append_target_er(self):
         """Test that 'settings append target.er' completes to 'settings append target.error-path'."""
         self.complete_from_to(
             'settings append target.er',
             'settings append target.error-path')

lldb/test/API/python_api/watchpoint/TestSetWatchpoint.py

def test_watch_val(self):
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         # Watch 'global' for read and write.
         value = frame0.FindValue('global', lldb.eValueTypeVariableGlobal)
         error = lldb.SBError()
         watchpoint = value.Watch(True, True, True, error)
+        if not watchpoint and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(value and watchpoint,
                         "Successfully found the variable and set a watchpoint")
         self.DebugSBValue(value)
 
         # Hide stdout if not running with '-t' option.
         if not self.TraceOn():
             self.HideStdout()
 

lldb/test/API/python_api/watchpoint/TestWatchpointIgnoreCount.py

def test_set_watch_ignore_count(self):
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         # Watch 'global' for read and write.
         value = frame0.FindValue('global', lldb.eValueTypeVariableGlobal)
         error = lldb.SBError()
         watchpoint = value.Watch(True, True, True, error)
+        if not watchpoint and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(value and watchpoint,
                         "Successfully found the variable and set a watchpoint")
         self.DebugSBValue(value)
 
         # Hide stdout if not running with '-t' option.
         if not self.TraceOn():
             self.HideStdout()
 

lldb/test/API/python_api/watchpoint/TestWatchpointIter.py

def test_watch_iter(self):
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         # Watch 'global' for read and write.
         value = frame0.FindValue('global', lldb.eValueTypeVariableGlobal)
         error = lldb.SBError()
         watchpoint = value.Watch(True, False, True, error)
+        if not watchpoint and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(value and watchpoint,
                         "Successfully found the variable and set a watchpoint")
         self.DebugSBValue(value)
 
         # Hide stdout if not running with '-t' option.
         if not self.TraceOn():
             self.HideStdout()
 

lldb/test/API/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

def test_watchpoint_cond_api(self):
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         # Watch 'global' for write.
         value = frame0.FindValue('global', lldb.eValueTypeVariableGlobal)
         error = lldb.SBError()
         watchpoint = value.Watch(True, False, True, error)
+        if not watchpoint and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(value and watchpoint,
                         "Successfully found the variable and set a watchpoint")
         self.DebugSBValue(value)
 
         # Now set the condition as "global==5".
         watchpoint.SetCondition('global==5')
         self.expect(watchpoint.GetCondition(), exe=False,
                     startstr='global==5')

lldb/test/API/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

def test_watch_location(self):
                                  lldb.eValueTypeVariableGlobal)
         pointee = value.CreateValueFromAddress(
             "pointee",
             value.GetValueAsUnsigned(0),
             value.GetType().GetPointeeType())
         # Watch for write to *g_char_ptr.
         error = lldb.SBError()
         watchpoint = value.WatchPointee(True, False, True, error)
+        if not watchpoint and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(value and watchpoint,
                         "Successfully found the pointer and set a watchpoint")
         self.DebugSBValue(value)
         self.DebugSBValue(pointee)
 
         # Hide stdout if not running with '-t' option.
         if not self.TraceOn():
             self.HideStdout()

lldb/test/API/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

def test_watch_address(self):
         pointee = value.CreateValueFromAddress(
             "pointee",
             value.GetValueAsUnsigned(0),
             value.GetType().GetPointeeType())
         # Watch for write to *g_char_ptr.
         error = lldb.SBError()
         watchpoint = target.WatchAddress(
             value.GetValueAsUnsigned(), 1, False, True, error)
+        if not watchpoint and self.getArchitecture() == 'powerpc64le' \
+           and error.GetCString() \
+               == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.assertTrue(value and watchpoint,
                         "Successfully found the pointer and set a watchpoint")
         self.DebugSBValue(value)
         self.DebugSBValue(pointee)
 
         # Hide stdout if not running with '-t' option.
         if not self.TraceOn():
             self.HideStdout()
def test_watch_address_with_invalid_watch_size(self):
             "pointee",
             value.GetValueAsUnsigned(0),
             value.GetType().GetPointeeType())
         # Watch for write to *g_char_ptr.
         error = lldb.SBError()
         watchpoint = target.WatchAddress(
             value.GetValueAsUnsigned(), 365, False, True, error)
         self.assertFalse(watchpoint)
+        if error.GetCString() \
+           == 'Target supports (0) hardware watchpoint slots.\n':
+            self.skipTest('Watchpoints are not supported')
         self.expect(error.GetCString(), exe=False,
                     substrs=['watch size of %d is not supported' % 365])

lldb/test/Shell/Subprocess/Inputs/check-follow-parent-wp.lldbinit

+process launch -s
+watchpoint set variable g_val
+# CHECK: error: Target supports (0) hardware watchpoint slots.

lldb/test/Shell/Subprocess/clone-follow-parent-wp.test

 # REQUIRES: native && (system-linux || system-netbsd) && dbregs-set
 # clone() tests fails on arm64 Linux, PR #49899
 # UNSUPPORTED: system-linux && target-aarch64
 # RUN: %clangxx_host -g %p/Inputs/fork.cpp -DTEST_CLONE -o %t
-# RUN: %lldb -b -s %s %t | FileCheck %s
+# RUN: (test $(uname -m) = ppc64le \
+# RUN:  && (%lldb -b -s %p/Inputs/check-follow-parent-wp.lldbinit %t || true) \
+# RUN:    2>&1 | FileCheck %p/Inputs/check-follow-parent-wp.lldbinit) \
+# RUN:   || %lldb -b -s %s %t | FileCheck %s
 process launch -s
 watchpoint set variable -w write g_val
 # CHECK: Watchpoint created:
 continue
 # CHECK-NOT: function run in parent
 # CHECK: stop reason = watchpoint
 continue
 # CHECK: function run in parent
 # CHECK: child exited: 0

lldb/test/Shell/Subprocess/fork-follow-parent-wp.test

 # REQUIRES: native && dbregs-set
 # UNSUPPORTED: system-windows
 # RUN: %clangxx_host -g %p/Inputs/fork.cpp -DTEST_FORK=fork -o %t
-# RUN: %lldb -b -s %s %t | FileCheck %s
+# RUN: (test $(uname -m) = ppc64le \
+# RUN:  && (%lldb -b -s %p/Inputs/check-follow-parent-wp.lldbinit %t || true) \
+# RUN:    2>&1 | FileCheck %p/Inputs/check-follow-parent-wp.lldbinit) \
+# RUN:   || %lldb -b -s %s %t | FileCheck %s
 process launch -s
 watchpoint set variable -w write g_val
 # CHECK: Watchpoint created:
 continue
 # CHECK-NOT: function run in parent
 # CHECK: stop reason = watchpoint
 continue
 # CHECK: function run in parent
 # CHECK: child exited: 0

lldb/test/Shell/Subprocess/vfork-follow-parent-wp.test

 # REQUIRES: native && dbregs-set
 # UNSUPPORTED: system-windows
 # UNSUPPORTED: system-darwin
 # RUN: %clangxx_host -g %p/Inputs/fork.cpp -DTEST_FORK=vfork -o %t
-# RUN: %lldb -b -s %s %t | FileCheck %s
+# RUN: (test $(uname -m) = ppc64le \
+# RUN:  && (%lldb -b -s %p/Inputs/check-follow-parent-wp.lldbinit %t || true) \
+# RUN:    2>&1 | FileCheck %p/Inputs/check-follow-parent-wp.lldbinit) \
+# RUN:   || %lldb -b -s %s %t | FileCheck %s
 process launch -s
 watchpoint set variable -w write g_val
 # CHECK: Watchpoint created:
 continue
 # CHECK-NOT: function run in parent
 # CHECK: stop reason = watchpoint
 continue
 # CHECK: function run in parent
 # CHECK: child exited: 0