[Lldb-commits] [lldb] 83fab8c - Revert "Make hit point counts reliable for architectures that stop before evaluation."
Jim Ingham via lldb-commits
lldb-commits at lists.llvm.org
Mon Jul 18 17:40:13 PDT 2022
Author: Jim Ingham
Date: 2022-07-18T17:38:43-07:00
New Revision: 83fab8cee9d6b9fa911195c20325b4512a7a22ef
URL: https://github.com/llvm/llvm-project/commit/83fab8cee9d6b9fa911195c20325b4512a7a22ef
DIFF: https://github.com/llvm/llvm-project/commit/83fab8cee9d6b9fa911195c20325b4512a7a22ef.diff
LOG: Revert "Make hit point counts reliable for architectures that stop before evaluation."
This reverts commit 5778ada8e54edb2bc2869505b88a959d1915c02f.
The watchpoint tests all stall on aarch64-ubuntu bots. Reverting till I can
get my hands on an system to test this out.
Added:
Modified:
lldb/include/lldb/Breakpoint/Watchpoint.h
lldb/include/lldb/Target/StopInfo.h
lldb/source/Target/StopInfo.cpp
lldb/test/API/commands/watchpoints/watchpoint_commands/condition/TestWatchpointConditionCmd.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentDelayWatchBreak.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentManyWatchpoints.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentNWatchNBreak.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalNWatchNBreak.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatch.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatchBreak.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointThreads.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneBreakpoint.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneDelayBreakpoint.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneSignal.py
lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentWatchBreak.py
Removed:
################################################################################
diff --git a/lldb/include/lldb/Breakpoint/Watchpoint.h b/lldb/include/lldb/Breakpoint/Watchpoint.h
index 7137b6e4a24c5..41b723a66b6a3 100644
--- a/lldb/include/lldb/Breakpoint/Watchpoint.h
+++ b/lldb/include/lldb/Breakpoint/Watchpoint.h
@@ -157,15 +157,12 @@ class Watchpoint : public std::enable_shared_from_this<Watchpoint>,
private:
friend class Target;
friend class WatchpointList;
- friend class StopInfoWatchpoint; // This needs to call UndoHitCount()
void ResetHistoricValues() {
m_old_value_sp.reset();
m_new_value_sp.reset();
}
- void UndoHitCount() { m_hit_counter.Decrement(); }
-
Target &m_target;
bool m_enabled; // Is this watchpoint enabled
bool m_is_hardware; // Is this a hardware watchpoint
diff --git a/lldb/include/lldb/Target/StopInfo.h b/lldb/include/lldb/Target/StopInfo.h
index 9527a6ea553e3..cdb906dcd7ede 100644
--- a/lldb/include/lldb/Target/StopInfo.h
+++ b/lldb/include/lldb/Target/StopInfo.h
@@ -17,7 +17,7 @@
namespace lldb_private {
-class StopInfo : public std::enable_shared_from_this<StopInfo> {
+class StopInfo {
friend class Process::ProcessEventData;
friend class ThreadPlanBase;
diff --git a/lldb/source/Target/StopInfo.cpp b/lldb/source/Target/StopInfo.cpp
index 5cf0f760aa249..00d30070c8c9f 100644
--- a/lldb/source/Target/StopInfo.cpp
+++ b/lldb/source/Target/StopInfo.cpp
@@ -20,7 +20,6 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h"
-#include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
@@ -691,128 +690,40 @@ class StopInfoWatchpoint : public StopInfo {
}
protected:
- using StopInfoWatchpointSP = std::shared_ptr<StopInfoWatchpoint>;
- // This plan is used to orchestrate stepping over the watchpoint for
- // architectures (e.g. ARM) that report the watch before running the watched
- // access. This is the sort of job you have to defer to the thread plans,
- // if you try to do it directly in the stop info and there are other threads
- // that needed to process this stop you will have yanked control away from
- // them and they won't behave correctly.
- class ThreadPlanStepOverWatchpoint : public ThreadPlanStepInstruction {
- public:
- ThreadPlanStepOverWatchpoint(Thread &thread,
- StopInfoWatchpointSP stop_info_sp,
- WatchpointSP watch_sp)
- : ThreadPlanStepInstruction(thread, false, true, eVoteNoOpinion,
- eVoteNoOpinion),
- m_stop_info_sp(stop_info_sp), m_watch_sp(watch_sp) {
- assert(watch_sp);
- m_watch_index = watch_sp->GetHardwareIndex();
- }
-
- bool DoWillResume(lldb::StateType resume_state,
- bool current_plan) override {
- if (m_did_reset_watchpoint) {
- GetThread().GetProcess()->DisableWatchpoint(m_watch_sp.get(), false);
- m_did_reset_watchpoint = false;
- }
- return true;
- }
-
- void DidPop() override {
- // Don't artifically keep the watchpoint alive.
- m_watch_sp.reset();
- }
-
- bool ShouldStop(Event *event_ptr) override {
- bool should_stop = ThreadPlanStepInstruction::ShouldStop(event_ptr);
- bool plan_done = MischiefManaged();
- if (plan_done) {
- m_stop_info_sp->SetStepOverPlanComplete();
- GetThread().SetStopInfo(m_stop_info_sp);
- ResetWatchpoint();
- }
- return should_stop;
- }
-
- protected:
- void ResetWatchpoint() {
- if (m_did_reset_watchpoint)
- return;
- m_did_reset_watchpoint = true;
- GetThread().GetProcess()->EnableWatchpoint(m_watch_sp.get(), false);
- m_watch_sp->SetHardwareIndex(m_watch_index);
- }
-
- private:
- StopInfoWatchpointSP m_stop_info_sp;
- WatchpointSP m_watch_sp;
- uint32_t m_watch_index = LLDB_INVALID_INDEX32;
- bool m_did_reset_watchpoint = false;
- };
-
bool ShouldStopSynchronous(Event *event_ptr) override {
- // If we are running our step-over the watchpoint plan, stop if it's done
- // and continue if it's not:
- if (m_using_step_over_plan)
- return m_step_over_plan_complete;
+ // ShouldStop() method is idempotent and should not affect hit count. See
+ // Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
+ // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
+ // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
+ // StopInfoWatchpoint::ShouldStop() and
+ // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
+ // StopInfoWatchpoint::PerformAction().
+ if (m_should_stop_is_valid)
+ return m_should_stop;
ThreadSP thread_sp(m_thread_wp.lock());
- assert(thread_sp);
- WatchpointSP wp_sp(
- thread_sp->CalculateTarget()->GetWatchpointList().FindByID(GetValue()));
- if (!wp_sp) {
- Log *log = GetLog(LLDBLog::Process);
-
- LLDB_LOGF(log,
- "Process::%s could not find watchpoint location id: %" PRId64
- "...",
- __FUNCTION__, GetValue());
+ if (thread_sp) {
+ WatchpointSP wp_sp(
+ thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
+ GetValue()));
+ if (wp_sp) {
+ // Check if we should stop at a watchpoint.
+ ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
+ StoppointCallbackContext context(event_ptr, exe_ctx, true);
+ m_should_stop = wp_sp->ShouldStop(&context);
+ } else {
+ Log *log = GetLog(LLDBLog::Process);
- m_should_stop = true;
- m_should_stop_is_valid = true;
- return true;
- }
+ LLDB_LOGF(log,
+ "Process::%s could not find watchpoint location id: %" PRId64
+ "...",
+ __FUNCTION__, GetValue());
- ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
- StoppointCallbackContext context(event_ptr, exe_ctx, true);
- m_should_stop = wp_sp->ShouldStop(&context);
- if (!m_should_stop) {
- // This won't happen at present because we only allow one watchpoint per
- // watched range. So we won't stop at a watched address with a disabled
- // watchpoint. If we start allowing overlapping watchpoints, then we
- // will have to make watchpoints be real "WatchpointSite" and delegate to
- // all the watchpoints sharing the site. In that case, the code below
- // would be the right thing to do.
- m_should_stop_is_valid = true;
- return m_should_stop;
- }
- // If this is a system where we need to execute the watchpoint by hand
- // after the hit, queue a thread plan to do that, and then say not to stop.
- // Otherwise, let the async action figure out whether the watchpoint should
- // stop
-
- ProcessSP process_sp = exe_ctx.GetProcessSP();
- uint32_t num;
- bool wp_triggers_after;
-
- if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
- .Success()) {
- if (wp_triggers_after)
- return true;
-
- StopInfoWatchpointSP me_as_siwp_sp
- = std::static_pointer_cast<StopInfoWatchpoint>(shared_from_this());
- ThreadPlanSP step_over_wp_sp(new ThreadPlanStepOverWatchpoint(
- *(thread_sp.get()), me_as_siwp_sp, wp_sp));
- Status error;
- error = thread_sp->QueueThreadPlan(step_over_wp_sp, false);
- m_using_step_over_plan = true;
- return !error.Success();
+ m_should_stop = true;
+ }
}
- // If we don't have to step over the watchpoint, just let the PerformAction
- // determine what we should do.
- return true;
+ m_should_stop_is_valid = true;
+ return m_should_stop;
}
bool ShouldStop(Event *event_ptr) override {
@@ -838,12 +749,57 @@ class StopInfoWatchpoint : public StopInfo {
thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
GetValue()));
if (wp_sp) {
- // This sentry object makes sure the current watchpoint is disabled
- // while performing watchpoint actions, and it is then enabled after we
- // are finished.
ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
ProcessSP process_sp = exe_ctx.GetProcessSP();
+ {
+ // check if this process is running on an architecture where
+ // watchpoints trigger before the associated instruction runs. if so,
+ // disable the WP, single-step and then re-enable the watchpoint
+ if (process_sp) {
+ uint32_t num;
+ bool wp_triggers_after;
+
+ if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
+ .Success()) {
+ if (!wp_triggers_after) {
+ // We need to preserve the watch_index before watchpoint is
+ // disable. Since Watchpoint::SetEnabled will clear the watch
+ // index. This will fix TestWatchpointIter failure
+ Watchpoint *wp = wp_sp.get();
+ uint32_t watch_index = wp->GetHardwareIndex();
+ process_sp->DisableWatchpoint(wp, false);
+ StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
+ assert(stored_stop_info_sp.get() == this);
+
+ Status new_plan_status;
+ ThreadPlanSP new_plan_sp(
+ thread_sp->QueueThreadPlanForStepSingleInstruction(
+ false, // step-over
+ false, // abort_other_plans
+ true, // stop_other_threads
+ new_plan_status));
+ if (new_plan_sp && new_plan_status.Success()) {
+ new_plan_sp->SetIsControllingPlan(true);
+ new_plan_sp->SetOkayToDiscard(false);
+ new_plan_sp->SetPrivate(true);
+ }
+ process_sp->GetThreadList().SetSelectedThreadByID(
+ thread_sp->GetID());
+ process_sp->ResumeSynchronous(nullptr);
+ process_sp->GetThreadList().SetSelectedThreadByID(
+ thread_sp->GetID());
+ thread_sp->SetStopInfo(stored_stop_info_sp);
+ process_sp->EnableWatchpoint(wp, false);
+ wp->SetHardwareIndex(watch_index);
+ }
+ }
+ }
+ }
+
+ // This sentry object makes sure the current watchpoint is disabled
+ // while performing watchpoint actions, and it is then enabled after we
+ // are finished.
WatchpointSentry sentry(process_sp, wp_sp);
/*
@@ -869,10 +825,18 @@ class StopInfoWatchpoint : public StopInfo {
}
}
- if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount()) {
+ // TODO: This condition should be checked in the synchronous part of the
+ // watchpoint code
+ // (Watchpoint::ShouldStop), so that we avoid pulling an event even if
+ // the watchpoint fails the ignore count condition. It is moved here
+ // temporarily, because for archs with
+ // watchpoint_exceptions_received=before, the code in the previous
+ // lines takes care of moving the inferior to next PC. We have to check
+ // the ignore count condition after this is done, otherwise we will hit
+ // same watchpoint multiple times until we pass ignore condition, but
+ // we won't actually be ignoring them.
+ if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
m_should_stop = false;
- m_should_stop_is_valid = true;
- }
Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
@@ -895,9 +859,10 @@ class StopInfoWatchpoint : public StopInfo {
Scalar scalar_value;
if (result_value_sp->ResolveValue(scalar_value)) {
if (scalar_value.ULongLong(1) == 0) {
- // The condition failed, which we consider "not having hit
- // the watchpoint" so undo the hit count here.
- wp_sp->UndoHitCount();
+ // We have been vetoed. This takes precedence over querying
+ // the watchpoint whether it should stop (aka ignore count
+ // and friends). See also StopInfoWatchpoint::ShouldStop()
+ // as well as Process::ProcessEventData::DoOnRemoval().
m_should_stop = false;
} else
m_should_stop = true;
@@ -981,16 +946,9 @@ class StopInfoWatchpoint : public StopInfo {
}
private:
- void SetStepOverPlanComplete() {
- assert(m_using_step_over_plan);
- m_step_over_plan_complete = true;
- }
-
bool m_should_stop = false;
bool m_should_stop_is_valid = false;
lldb::addr_t m_watch_hit_addr;
- bool m_step_over_plan_complete = false;
- bool m_using_step_over_plan = false;
};
// StopInfoUnixSignal
diff --git a/lldb/test/API/commands/watchpoints/watchpoint_commands/condition/TestWatchpointConditionCmd.py b/lldb/test/API/commands/watchpoints/watchpoint_commands/condition/TestWatchpointConditionCmd.py
index fee6b8b582c24..b3b0e102e6c3b 100644
--- a/lldb/test/API/commands/watchpoints/watchpoint_commands/condition/TestWatchpointConditionCmd.py
+++ b/lldb/test/API/commands/watchpoints/watchpoint_commands/condition/TestWatchpointConditionCmd.py
@@ -82,4 +82,4 @@ def test_watchpoint_cond(self):
# Use the '-v' option to do verbose listing of the watchpoint.
# The hit count should now be 2.
self.expect("watchpoint list -v",
- substrs=['hit_count = 1'])
+ substrs=['hit_count = 5'])
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentDelayWatchBreak.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentDelayWatchBreak.py
index 0a958c0c38c79..ba648b87ea8d0 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentDelayWatchBreak.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentDelayWatchBreak.py
@@ -11,6 +11,10 @@ class ConcurrentDelayWatchBreak(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://81811539")
@add_test_categories(["watchpoint"])
def test(self):
"""Test (1-second delay) watchpoint and a breakpoint in multiple threads."""
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentManyWatchpoints.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentManyWatchpoints.py
index b74d0c7097d6c..cd82dab827560 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentManyWatchpoints.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentManyWatchpoints.py
@@ -10,6 +10,10 @@ class ConcurrentManyWatchpoints(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
@skipIfOutOfTreeDebugserver
def test(self):
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentNWatchNBreak.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentNWatchNBreak.py
index 40b548e708e4a..0dab66598eaca 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentNWatchNBreak.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentNWatchNBreak.py
@@ -13,6 +13,10 @@ class ConcurrentNWatchNBreak(ConcurrentEventsBase):
@skipIf(triple='^mips')
@expectedFailureAll(archs=["aarch64"], oslist=["freebsd"],
bugnumber="llvm.org/pr49433")
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test with 5 watchpoint and breakpoint threads."""
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalNWatchNBreak.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalNWatchNBreak.py
index bcf1c6409b92b..2478a49de4e38 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalNWatchNBreak.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalNWatchNBreak.py
@@ -14,6 +14,10 @@ class ConcurrentSignalNWatchNBreak(ConcurrentEventsBase):
@expectedFailureNetBSD
@expectedFailureAll(archs=["aarch64"], oslist=["freebsd"],
bugnumber="llvm.org/pr49433")
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test one signal thread with 5 watchpoint and breakpoint threads."""
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatch.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatch.py
index 421db5a31132b..2922070f9da6d 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatch.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatch.py
@@ -11,6 +11,10 @@ class ConcurrentSignalWatch(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test a watchpoint and a signal in multiple threads."""
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatchBreak.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatchBreak.py
index 50fead6f499f5..3ca3a8661c016 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatchBreak.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentSignalWatchBreak.py
@@ -12,6 +12,10 @@ class ConcurrentSignalWatchBreak(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
@expectedFailureNetBSD
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test a signal/watchpoint/breakpoint in multiple threads."""
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointThreads.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointThreads.py
index 1e8a2d0632863..5cddeee587481 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointThreads.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointThreads.py
@@ -11,6 +11,10 @@ class ConcurrentTwoWatchpointThreads(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test two threads that trigger a watchpoint. """
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneBreakpoint.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneBreakpoint.py
index 88eae0accdf41..c83862d25d50a 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneBreakpoint.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneBreakpoint.py
@@ -11,6 +11,10 @@ class ConcurrentTwoWatchpointsOneBreakpoint(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test two threads that trigger a watchpoint and one breakpoint thread. """
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneDelayBreakpoint.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneDelayBreakpoint.py
index 8cad1213221ac..f1b65220a091a 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneDelayBreakpoint.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneDelayBreakpoint.py
@@ -11,6 +11,10 @@ class ConcurrentTwoWatchpointsOneDelayBreakpoint(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test two threads that trigger a watchpoint and one (1 second delay) breakpoint thread. """
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneSignal.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneSignal.py
index 4cca7ecc64e72..acc08e1dd0772 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneSignal.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneSignal.py
@@ -12,6 +12,10 @@ class ConcurrentTwoWatchpointsOneSignal(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
@expectedFailureNetBSD
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
@add_test_categories(["watchpoint"])
def test(self):
"""Test two threads that trigger a watchpoint and one signal thread. """
diff --git a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentWatchBreak.py b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentWatchBreak.py
index 1e95aa2c19f2b..7d3a759e09cee 100644
--- a/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentWatchBreak.py
+++ b/lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentWatchBreak.py
@@ -12,6 +12,10 @@ class ConcurrentWatchBreak(ConcurrentEventsBase):
# Atomic sequences are not supported yet for MIPS in LLDB.
@skipIf(triple='^mips')
@add_test_categories(["watchpoint"])
+ @skipIf(
+ oslist=["ios", "watchos", "tvos", "bridgeos", "macosx"],
+ archs=['arm64', 'arm64e', 'arm64_32', 'arm'],
+ bugnumber="rdar://93863107")
def test(self):
"""Test watchpoint and a breakpoint in multiple threads."""
More information about the lldb-commits
mailing list