https://github.com/jeffreytan81 created https://github.com/llvm/llvm-project/pull/90930
None >From b72df8cf2a047ed731913609b58bdb4a3601e111 Mon Sep 17 00:00:00 2001 From: jeffreytan81 <jeffrey...@fb.com> Date: Thu, 2 May 2024 18:12:04 -0700 Subject: [PATCH] Single thread timeout feature --- lldb/include/lldb/Target/Process.h | 11 +- lldb/include/lldb/Target/StopInfo.h | 4 + lldb/include/lldb/Target/Thread.h | 2 + lldb/include/lldb/Target/ThreadPlan.h | 8 +- .../Target/ThreadPlanSingleThreadTimeout.h | 89 ++++++++ lldb/include/lldb/Target/ThreadPlanStepOut.h | 1 + .../lldb/Target/ThreadPlanStepOverRange.h | 5 + lldb/include/lldb/lldb-enumerations.h | 1 + lldb/source/API/SBThread.cpp | 6 + .../source/Interpreter/CommandInterpreter.cpp | 2 +- .../GDBRemoteCommunicationServerLLGS.cpp | 2 + .../Process/gdb-remote/ProcessGDBRemote.cpp | 61 +++++- .../Process/gdb-remote/ProcessGDBRemote.h | 6 + lldb/source/Target/CMakeLists.txt | 1 + lldb/source/Target/Process.cpp | 23 +- lldb/source/Target/StopInfo.cpp | 37 ++++ lldb/source/Target/TargetProperties.td | 4 + lldb/source/Target/Thread.cpp | 9 +- lldb/source/Target/ThreadPlan.cpp | 1 + .../Target/ThreadPlanSingleThreadTimeout.cpp | 205 ++++++++++++++++++ lldb/source/Target/ThreadPlanStepInRange.cpp | 2 + .../source/Target/ThreadPlanStepOverRange.cpp | 17 +- lldb/source/Target/ThreadPlanStepRange.cpp | 9 +- .../single-thread-step/Makefile | 4 + .../TestSingleThreadStepTimeout.py | 123 +++++++++++ .../single-thread-step/main.cpp | 62 ++++++ lldb/tools/lldb-dap/JSONUtils.cpp | 3 + lldb/tools/lldb-dap/LLDBUtils.cpp | 1 + 28 files changed, 671 insertions(+), 28 deletions(-) create mode 100644 lldb/include/lldb/Target/ThreadPlanSingleThreadTimeout.h create mode 100644 lldb/source/Target/ThreadPlanSingleThreadTimeout.cpp create mode 100644 lldb/test/API/functionalities/single-thread-step/Makefile create mode 100644 lldb/test/API/functionalities/single-thread-step/TestSingleThreadStepTimeout.py create mode 100644 lldb/test/API/functionalities/single-thread-step/main.cpp diff --git a/lldb/include/lldb/Target/Process.h b/lldb/include/lldb/Target/Process.h index aac0cf51680a9e..7e758dbb9f6457 100644 --- a/lldb/include/lldb/Target/Process.h +++ b/lldb/include/lldb/Target/Process.h @@ -1312,11 +1312,13 @@ class Process : public std::enable_shared_from_this<Process>, size_t GetThreadStatus(Stream &ostrm, bool only_threads_with_stop_reason, uint32_t start_frame, uint32_t num_frames, - uint32_t num_frames_with_source, - bool stop_format); + uint32_t num_frames_with_source, bool stop_format); void SendAsyncInterrupt(); + // Send an async interrupt and receive stop from a specific /p thread. + void SendAsyncInterrupt(Thread *thread); + // Notify this process class that modules got loaded. // // If subclasses override this method, they must call this version before @@ -3102,6 +3104,11 @@ void PruneThreadPlans(); // Resume will only request a resume, using this // flag to check. + lldb::tid_t m_interrupt_tid; /// The tid of the thread that issued the async + /// interrupt, used by thread plan timeout. It + /// can be LLDB_INVALID_THREAD_ID to indicate + /// user level async interrupt. + /// This is set at the beginning of Process::Finalize() to stop functions /// from looking up or creating things during or after a finalize call. std::atomic<bool> m_finalizing; diff --git a/lldb/include/lldb/Target/StopInfo.h b/lldb/include/lldb/Target/StopInfo.h index d1848fcbbbdb19..fae90364deaf0a 100644 --- a/lldb/include/lldb/Target/StopInfo.h +++ b/lldb/include/lldb/Target/StopInfo.h @@ -123,6 +123,10 @@ class StopInfo : public std::enable_shared_from_this<StopInfo> { const char *description = nullptr, std::optional<int> code = std::nullopt); + static lldb::StopInfoSP + CreateStopReasonWithInterrupt(Thread &thread, int signo, + const char *description); + static lldb::StopInfoSP CreateStopReasonToTrace(Thread &thread); static lldb::StopInfoSP diff --git a/lldb/include/lldb/Target/Thread.h b/lldb/include/lldb/Target/Thread.h index c17bddf4d98b85..584093348b4c6a 100644 --- a/lldb/include/lldb/Target/Thread.h +++ b/lldb/include/lldb/Target/Thread.h @@ -57,6 +57,8 @@ class ThreadProperties : public Properties { bool GetStepOutAvoidsNoDebug() const; uint64_t GetMaxBacktraceDepth() const; + + uint64_t GetSingleThreadPlanTimeout() const; }; class Thread : public std::enable_shared_from_this<Thread>, diff --git a/lldb/include/lldb/Target/ThreadPlan.h b/lldb/include/lldb/Target/ThreadPlan.h index bf68a42e54d18f..640e997caf7b3d 100644 --- a/lldb/include/lldb/Target/ThreadPlan.h +++ b/lldb/include/lldb/Target/ThreadPlan.h @@ -302,7 +302,8 @@ class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>, eKindStepInRange, eKindRunToAddress, eKindStepThrough, - eKindStepUntil + eKindStepUntil, + eKindSingleThreadTimeout, }; virtual ~ThreadPlan(); @@ -483,6 +484,8 @@ class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>, return m_takes_iteration_count; } + virtual lldb::StateType GetPlanRunState() = 0; + protected: // Constructors and Destructors ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread, @@ -522,8 +525,6 @@ class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>, GetThread().SetStopInfo(stop_reason_sp); } - virtual lldb::StateType GetPlanRunState() = 0; - bool IsUsuallyUnexplainedStopReason(lldb::StopReason); Status m_status; @@ -590,6 +591,7 @@ class ThreadPlanNull : public ThreadPlan { const Status &GetStatus() { return m_status; } protected: + friend class ThreadPlanSingleThreadTimeout; bool DoPlanExplainsStop(Event *event_ptr) override; lldb::StateType GetPlanRunState() override; diff --git a/lldb/include/lldb/Target/ThreadPlanSingleThreadTimeout.h b/lldb/include/lldb/Target/ThreadPlanSingleThreadTimeout.h new file mode 100644 index 00000000000000..777ed55fbae26b --- /dev/null +++ b/lldb/include/lldb/Target/ThreadPlanSingleThreadTimeout.h @@ -0,0 +1,89 @@ +//===-- ThreadPlanSingleThreadTimeout.h -------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_TARGET_THREADPLANSINGLETHREADTIMEOUT_H +#define LLDB_TARGET_THREADPLANSINGLETHREADTIMEOUT_H + +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlan.h" +#include "lldb/Utility/Event.h" +#include "lldb/Utility/LLDBLog.h" +#include "lldb/Utility/State.h" + +#include <thread> + +namespace lldb_private { + +// +// Thread plan used by single thread execution to issue timeout. This is useful +// to detect potential deadlock in single thread execution. The timeout measures +// the elapsed time from the last internal stop and got reset by each internal +// stops to ensure we are accurately detecting execution not moving forward. +// This means this thread plan can be created/destroyed multiple times by the +// parent execution plan. +// +// When timeout happens, the thread plan resolves the potential deadlock by +// issuing a thread specific async interrupt to enter stop state, then all +// threads execution are resumed to resolve the potential deadlock. +// +class ThreadPlanSingleThreadTimeout : public ThreadPlan { +public: + ~ThreadPlanSingleThreadTimeout() override; + + static void ResetIfNeeded(Thread &thread); + + void GetDescription(Stream *s, lldb::DescriptionLevel level) override; + bool ValidatePlan(Stream *error) override { return true; } + bool WillStop() override; + void DidPop() override; + + bool DoPlanExplainsStop(Event *event_ptr) override; + + lldb::StateType GetPlanRunState() override; + static void TimeoutThreadFunc(ThreadPlanSingleThreadTimeout *self); + + bool MischiefManaged() override; + + bool ShouldStop(Event *event_ptr) override; + void SetStopOthers(bool new_value) override; + bool StopOthers() override; + +private: + ThreadPlanSingleThreadTimeout(Thread &thread); + + static bool IsAlive() { return s_instance != nullptr; } + + enum class State { + WaitTimeout, // Waiting for timeout. + AsyncInterrupt, // Async interrupt has been issued. + Done, // Finished resume all threads. + }; + + static ThreadPlanSingleThreadTimeout *s_instance; + static State s_prev_state; + + bool HandleEvent(Event *event_ptr); + void HandleTimeout(); + + static std::string StateToString(State state); + + ThreadPlanSingleThreadTimeout(const ThreadPlanSingleThreadTimeout &) = delete; + const ThreadPlanSingleThreadTimeout & + operator=(const ThreadPlanSingleThreadTimeout &) = delete; + + State m_state; + std::mutex m_mutex; + std::condition_variable m_wakeup_cv; + // Whether the timer thread should exit or not. + bool m_exit_flag; + std::thread m_timer_thread; +}; + +} // namespace lldb_private + +#endif // LLDB_TARGET_THREADPLANSINGLETHREADTIMEOUT_H diff --git a/lldb/include/lldb/Target/ThreadPlanStepOut.h b/lldb/include/lldb/Target/ThreadPlanStepOut.h index b1d8769f7c546e..013c675afc33d0 100644 --- a/lldb/include/lldb/Target/ThreadPlanStepOut.h +++ b/lldb/include/lldb/Target/ThreadPlanStepOut.h @@ -30,6 +30,7 @@ class ThreadPlanStepOut : public ThreadPlan, public ThreadPlanShouldStopHere { bool ValidatePlan(Stream *error) override; bool ShouldStop(Event *event_ptr) override; bool StopOthers() override; + void SetStopOthers(bool new_value) override { m_stop_others = new_value; } lldb::StateType GetPlanRunState() override; bool WillStop() override; bool MischiefManaged() override; diff --git a/lldb/include/lldb/Target/ThreadPlanStepOverRange.h b/lldb/include/lldb/Target/ThreadPlanStepOverRange.h index 8585ac62f09b35..6b9fdadf0cbd96 100644 --- a/lldb/include/lldb/Target/ThreadPlanStepOverRange.h +++ b/lldb/include/lldb/Target/ThreadPlanStepOverRange.h @@ -27,6 +27,7 @@ class ThreadPlanStepOverRange : public ThreadPlanStepRange, ~ThreadPlanStepOverRange() override; void GetDescription(Stream *s, lldb::DescriptionLevel level) override; + void SetStopOthers(bool new_value) override; bool ShouldStop(Event *event_ptr) override; protected: @@ -42,8 +43,12 @@ class ThreadPlanStepOverRange : public ThreadPlanStepRange, void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info); bool IsEquivalentContext(const SymbolContext &context); + // Clear and create a new ThreadPlanSingleThreadTimeout to detect if program + // is moving forward. + void ResetSingleThreadTimeout(); bool m_first_resume; + lldb::RunMode m_run_mode; ThreadPlanStepOverRange(const ThreadPlanStepOverRange &) = delete; const ThreadPlanStepOverRange & diff --git a/lldb/include/lldb/lldb-enumerations.h b/lldb/include/lldb/lldb-enumerations.h index 15e45857186091..2000931913c81b 100644 --- a/lldb/include/lldb/lldb-enumerations.h +++ b/lldb/include/lldb/lldb-enumerations.h @@ -253,6 +253,7 @@ enum StopReason { eStopReasonFork, eStopReasonVFork, eStopReasonVForkDone, + eStopReasonInterrupt, ///< Thread requested interrupt }; /// Command Return Status Types. diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index ac3e2cd25daa94..c6925096e3cb1a 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -192,6 +192,9 @@ size_t SBThread::GetStopReasonDataCount() { case eStopReasonSignal: return 1; + case eStopReasonInterrupt: + return 1; + case eStopReasonException: return 1; @@ -261,6 +264,9 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { case eStopReasonSignal: return stop_info_sp->GetValue(); + case eStopReasonInterrupt: + return stop_info_sp->GetValue(); + case eStopReasonException: return stop_info_sp->GetValue(); diff --git a/lldb/source/Interpreter/CommandInterpreter.cpp b/lldb/source/Interpreter/CommandInterpreter.cpp index 4c58ecc3c1848f..d327822db7bd37 100644 --- a/lldb/source/Interpreter/CommandInterpreter.cpp +++ b/lldb/source/Interpreter/CommandInterpreter.cpp @@ -2500,7 +2500,7 @@ bool CommandInterpreter::DidProcessStopAbnormally() const { const StopReason reason = stop_info->GetStopReason(); if (reason == eStopReasonException || reason == eStopReasonInstrumentation || - reason == eStopReasonProcessorTrace) + reason == eStopReasonProcessorTrace || reason == eStopReasonInterrupt) return true; if (reason == eStopReasonSignal) { diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp index ae1a77e5be8321..b3c0359b7dcf7b 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp @@ -714,6 +714,8 @@ static const char *GetStopReasonString(StopReason stop_reason) { return "vfork"; case eStopReasonVForkDone: return "vforkdone"; + case eStopReasonInterrupt: + return "async interrupt"; case eStopReasonInstrumentation: case eStopReasonInvalid: case eStopReasonPlanComplete: diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp index 871683a605686f..b93aad8808f5bd 100644 --- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp @@ -1730,14 +1730,24 @@ ThreadSP ProcessGDBRemote::SetThreadStopInfo( thread_sp = memory_thread_sp; if (exc_type != 0) { - const size_t exc_data_size = exc_data.size(); - - thread_sp->SetStopInfo( - StopInfoMachException::CreateStopReasonWithMachException( - *thread_sp, exc_type, exc_data_size, - exc_data_size >= 1 ? exc_data[0] : 0, - exc_data_size >= 2 ? exc_data[1] : 0, - exc_data_size >= 3 ? exc_data[2] : 0)); + // For thread plan async interrupt, creating stop info on the + // original async interrupt request thread instead. If interrupt thread + // does not exist anymore we fallback to current signal receiving thread + // instead. + ThreadSP interrupt_thread; + if (m_interrupt_tid != LLDB_INVALID_THREAD_ID) + interrupt_thread = HandleThreadAsyncInterrupt(signo, description); + if (interrupt_thread) + thread_sp = interrupt_thread; + else { + const size_t exc_data_size = exc_data.size(); + thread_sp->SetStopInfo( + StopInfoMachException::CreateStopReasonWithMachException( + *thread_sp, exc_type, exc_data_size, + exc_data_size >= 1 ? exc_data[0] : 0, + exc_data_size >= 2 ? exc_data[1] : 0, + exc_data_size >= 3 ? exc_data[2] : 0)); + } } else { bool handled = false; bool did_exec = false; @@ -1936,9 +1946,20 @@ ThreadSP ProcessGDBRemote::SetThreadStopInfo( *thread_sp, signo, description.c_str())); } } - if (!handled) - thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal( - *thread_sp, signo, description.c_str())); + if (!handled) { + // For thread plan async interrupt, creating stop info on the + // original async interrupt request thread instead. If interrupt + // thread does not exist anymore we fallback to current signal + // receiving thread instead. + ThreadSP interrupt_thread; + if (m_interrupt_tid != LLDB_INVALID_THREAD_ID) + interrupt_thread = HandleThreadAsyncInterrupt(signo, description); + if (interrupt_thread) + thread_sp = interrupt_thread; + else + thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal( + *thread_sp, signo, description.c_str())); + } } if (!description.empty()) { @@ -1957,6 +1978,24 @@ ThreadSP ProcessGDBRemote::SetThreadStopInfo( return thread_sp; } +ThreadSP +ProcessGDBRemote::HandleThreadAsyncInterrupt(uint8_t signo, + const std::string &description) { + ThreadSP thread_sp; + { + std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex()); + thread_sp = m_thread_list_real.FindThreadByProtocolID(m_interrupt_tid, + /*can_update=*/false); + } + if (thread_sp) + thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithInterrupt( + *thread_sp, signo, description.c_str())); + // Clear m_interrupt_tid regardless we can find original interrupt thread or + // not. + m_interrupt_tid = LLDB_INVALID_THREAD_ID; + return thread_sp; +} + lldb::ThreadSP ProcessGDBRemote::SetThreadStopInfo(StructuredData::Dictionary *thread_dict) { static constexpr llvm::StringLiteral g_key_tid("tid"); diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h index 610a1ee0b34d2f..615831dd7e6f60 100644 --- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h +++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h @@ -440,6 +440,12 @@ class ProcessGDBRemote : public Process, void HandleStopReply() override; void HandleAsyncStructuredDataPacket(llvm::StringRef data) override; + // Handle thread specific async interrupt and return the original thread + // that requested the async interrupt. It can be null if original thread + // has exited. + lldb::ThreadSP HandleThreadAsyncInterrupt(uint8_t signo, + const std::string &description); + void SetThreadPc(const lldb::ThreadSP &thread_sp, uint64_t index); using ModuleCacheKey = std::pair<std::string, std::string>; // KeyInfo for the cached module spec DenseMap. diff --git a/lldb/source/Target/CMakeLists.txt b/lldb/source/Target/CMakeLists.txt index cf4818eae3eb8b..d1209d29245d54 100644 --- a/lldb/source/Target/CMakeLists.txt +++ b/lldb/source/Target/CMakeLists.txt @@ -59,6 +59,7 @@ add_lldb_library(lldbTarget ThreadPlanCallUserExpression.cpp ThreadPlanPython.cpp ThreadPlanRunToAddress.cpp + ThreadPlanSingleThreadTimeout.cpp ThreadPlanShouldStopHere.cpp ThreadPlanStepInRange.cpp ThreadPlanStepInstruction.cpp diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp index 30c240b064b59c..3e5e4fe58b4b3b 100644 --- a/lldb/source/Target/Process.cpp +++ b/lldb/source/Target/Process.cpp @@ -446,7 +446,8 @@ Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp, m_memory_cache(*this), m_allocated_memory_cache(*this), m_should_detach(false), m_next_event_action_up(), m_public_run_lock(), m_private_run_lock(), m_currently_handling_do_on_removals(false), - m_resume_requested(false), m_finalizing(false), m_destructing(false), + m_resume_requested(false), m_interrupt_tid(LLDB_INVALID_THREAD_ID), + m_finalizing(false), m_destructing(false), m_clear_thread_plans_on_stop(false), m_force_next_event_delivery(false), m_last_broadcast_state(eStateInvalid), m_destroy_in_process(false), m_can_interpret_function_calls(false), m_run_thread_plan_lock(), @@ -863,6 +864,7 @@ bool Process::HandleProcessStateChangedEvent( case eStopReasonThreadExiting: case eStopReasonInstrumentation: case eStopReasonProcessorTrace: + case eStopReasonInterrupt: if (!other_thread) other_thread = thread; break; @@ -3679,7 +3681,13 @@ void Process::ControlPrivateStateThread(uint32_t signal) { } } -void Process::SendAsyncInterrupt() { +void Process::SendAsyncInterrupt() { SendAsyncInterrupt(nullptr); } + +void Process::SendAsyncInterrupt(Thread *thread) { + if (thread != nullptr) + m_interrupt_tid = thread->GetProtocolID(); + else + m_interrupt_tid = LLDB_INVALID_THREAD_ID; if (PrivateStateThreadIsValid()) m_private_state_broadcaster.BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr); @@ -3905,9 +3913,14 @@ thread_result_t Process::RunPrivateStateThread(bool is_secondary_thread) { if (interrupt_requested) { if (StateIsStoppedState(internal_state, true)) { - // We requested the interrupt, so mark this as such in the stop event - // so clients can tell an interrupted process from a natural stop - ProcessEventData::SetInterruptedInEvent(event_sp.get(), true); + // Oly mark interrupt event if it is not thread specific async + // interrupt. + if (m_interrupt_tid == LLDB_INVALID_THREAD_ID) { + // We requested the interrupt, so mark this as such in the stop + // event so clients can tell an interrupted process from a natural + // stop + ProcessEventData::SetInterruptedInEvent(event_sp.get(), true); + } interrupt_requested = false; } else if (log) { LLDB_LOGF(log, diff --git a/lldb/source/Target/StopInfo.cpp b/lldb/source/Target/StopInfo.cpp index 95f78056b16445..936d49cc312d7e 100644 --- a/lldb/source/Target/StopInfo.cpp +++ b/lldb/source/Target/StopInfo.cpp @@ -1125,6 +1125,38 @@ class StopInfoUnixSignal : public StopInfo { std::optional<int> m_code; }; +// StopInfoInterrupt + +class StopInfoInterrupt : public StopInfo { +public: + StopInfoInterrupt(Thread &thread, int signo, const char *description) + : StopInfo(thread, signo) { + SetDescription(description); + } + + ~StopInfoInterrupt() override = default; + + StopReason GetStopReason() const override { + return lldb::eStopReasonInterrupt; + } + + bool ShouldStopSynchronous(Event *event_ptr) override { return true; } + + bool ShouldStop(Event *event_ptr) override { + ThreadSP thread_sp(m_thread_wp.lock()); + if (thread_sp) + return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value); + return false; + } + + const char *GetDescription() override { + if (m_description.empty()) { + m_description = "async interrupt"; + } + return m_description.c_str(); + } +}; + // StopInfoTrace class StopInfoTrace : public StopInfo { @@ -1390,6 +1422,11 @@ StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo, return StopInfoSP(new StopInfoUnixSignal(thread, signo, description, code)); } +StopInfoSP StopInfo::CreateStopReasonWithInterrupt(Thread &thread, int signo, + const char *description) { + return StopInfoSP(new StopInfoInterrupt(thread, signo, description)); +} + StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) { return StopInfoSP(new StopInfoTrace(thread)); } diff --git a/lldb/source/Target/TargetProperties.td b/lldb/source/Target/TargetProperties.td index 7f79218e0a6a4d..1e08d352a6e1ce 100644 --- a/lldb/source/Target/TargetProperties.td +++ b/lldb/source/Target/TargetProperties.td @@ -310,6 +310,10 @@ let Definition = "thread" in { def MaxBacktraceDepth: Property<"max-backtrace-depth", "UInt64">, DefaultUnsignedValue<600000>, Desc<"Maximum number of frames to backtrace.">; + def SingleThreadPlanTimeout: Property<"single-thread-plan-timeout", "UInt64">, + Global, + DefaultUnsignedValue<1000>, + Desc<"The time in milliseconds to wait for single thread ThreadPlan to move forward before resuming all threads to resolve any potential deadlock.">; } let Definition = "language" in { diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp index e75f5a356cec2f..7b4988f7955045 100644 --- a/lldb/source/Target/Thread.cpp +++ b/lldb/source/Target/Thread.cpp @@ -143,6 +143,12 @@ uint64_t ThreadProperties::GetMaxBacktraceDepth() const { idx, g_thread_properties[idx].default_uint_value); } +uint64_t ThreadProperties::GetSingleThreadPlanTimeout() const { + const uint32_t idx = ePropertySingleThreadPlanTimeout; + return GetPropertyAtIndexAs<uint64_t>( + idx, g_thread_properties[idx].default_uint_value); +} + // Thread Event Data llvm::StringRef Thread::ThreadEventData::GetFlavorString() { @@ -813,7 +819,6 @@ bool Thread::ShouldStop(Event *event_ptr) { // decide whether they still need to do more work. bool done_processing_current_plan = false; - if (!current_plan->PlanExplainsStop(event_ptr)) { if (current_plan->TracerExplainsStop()) { done_processing_current_plan = true; @@ -1715,6 +1720,8 @@ std::string Thread::StopReasonAsString(lldb::StopReason reason) { return "instrumentation break"; case eStopReasonProcessorTrace: return "processor trace"; + case eStopReasonInterrupt: + return "async interrupt"; } return "StopReason = " + std::to_string(reason); diff --git a/lldb/source/Target/ThreadPlan.cpp b/lldb/source/Target/ThreadPlan.cpp index 7927fc3140145a..f05e1faf343a66 100644 --- a/lldb/source/Target/ThreadPlan.cpp +++ b/lldb/source/Target/ThreadPlan.cpp @@ -174,6 +174,7 @@ bool ThreadPlan::IsUsuallyUnexplainedStopReason(lldb::StopReason reason) { case eStopReasonFork: case eStopReasonVFork: case eStopReasonVForkDone: + case eStopReasonInterrupt: return true; default: return false; diff --git a/lldb/source/Target/ThreadPlanSingleThreadTimeout.cpp b/lldb/source/Target/ThreadPlanSingleThreadTimeout.cpp new file mode 100644 index 00000000000000..11575d347105ec --- /dev/null +++ b/lldb/source/Target/ThreadPlanSingleThreadTimeout.cpp @@ -0,0 +1,205 @@ +//===-- ThreadPlanStepOverRange.cpp ---------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/Target/ThreadPlanSingleThreadTimeout.h" +#include "lldb/Symbol/Block.h" +#include "lldb/Symbol/CompileUnit.h" +#include "lldb/Symbol/Function.h" +#include "lldb/Symbol/LineTable.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlanStepOut.h" +#include "lldb/Target/ThreadPlanStepThrough.h" +#include "lldb/Utility/LLDBLog.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/Stream.h" + +using namespace lldb_private; +using namespace lldb; + +ThreadPlanSingleThreadTimeout *ThreadPlanSingleThreadTimeout::s_instance = + nullptr; +ThreadPlanSingleThreadTimeout::State + ThreadPlanSingleThreadTimeout::s_prev_state = State::WaitTimeout; + +ThreadPlanSingleThreadTimeout::ThreadPlanSingleThreadTimeout(Thread &thread) + : ThreadPlan(ThreadPlan::eKindSingleThreadTimeout, "Single thread timeout", + thread, eVoteNo, eVoteNoOpinion), + m_state(State::WaitTimeout), m_exit_flag(false) { + m_timer_thread = std::thread(TimeoutThreadFunc, this); + s_instance = this; + m_state = s_prev_state; +} + +ThreadPlanSingleThreadTimeout::~ThreadPlanSingleThreadTimeout() { + std::lock_guard<std::mutex> lock(m_mutex); + s_instance = nullptr; + if (m_state == State::Done) + m_state = State::WaitTimeout; + s_prev_state = m_state; +} + +void ThreadPlanSingleThreadTimeout::GetDescription( + Stream *s, lldb::DescriptionLevel level) { + s->Printf("Single thread timeout, state(%s)", StateToString(m_state).c_str()); +} + +std::string ThreadPlanSingleThreadTimeout::StateToString(State state) { + switch (state) { + case State::WaitTimeout: + return "WaitTimeout"; + case State::AsyncInterrupt: + return "AsyncInterrupt"; + case State::Done: + return "Done"; + } +} + +void ThreadPlanSingleThreadTimeout::ResetIfNeeded(Thread &thread) { + uint64_t timeout_in_ms = thread.GetSingleThreadPlanTimeout(); + if (timeout_in_ms == 0) + return; + + // TODO: mutex? + if (ThreadPlanSingleThreadTimeout::IsAlive()) + return; + + // Do not create timeout if we are not stopping other threads. + if (!thread.GetCurrentPlan()->StopOthers()) + return; + + auto timeout_plan = new ThreadPlanSingleThreadTimeout(thread); + ThreadPlanSP thread_plan_sp(timeout_plan); + auto status = thread.QueueThreadPlan(thread_plan_sp, + /*abort_other_plans*/ false); + Log *log = GetLog(LLDBLog::Step); + LLDB_LOGF(log, "ThreadPlanSingleThreadTimeout pushing a new one"); +} + +bool ThreadPlanSingleThreadTimeout::WillStop() { + Log *log = GetLog(LLDBLog::Step); + LLDB_LOGF(log, "ThreadPlanSingleThreadTimeout::WillStop()."); + + // Reset the state during stop. + std::lock_guard<std::mutex> lock(m_mutex); + s_prev_state = State::WaitTimeout; + return true; +} + +void ThreadPlanSingleThreadTimeout::DidPop() { + Log *log = GetLog(LLDBLog::Step); + { + std::lock_guard<std::mutex> lock(m_mutex); + LLDB_LOGF(log, "ThreadPlanSingleThreadTimeout::DidPop()."); + // Tell timer thread to exit. + m_exit_flag = true; + } + m_wakeup_cv.notify_one(); + // Wait for timer thread to exit. + m_timer_thread.join(); +} + +bool ThreadPlanSingleThreadTimeout::DoPlanExplainsStop(Event *event_ptr) { + lldb::StateType stop_state = + Process::ProcessEventData::GetStateFromEvent(event_ptr); + Log *log = GetLog(LLDBLog::Step); + LLDB_LOGF( + log, + "ThreadPlanSingleThreadTimeout::DoPlanExplainsStop(): got event: %s.", + StateAsCString(stop_state)); + return true; +} + +lldb::StateType ThreadPlanSingleThreadTimeout::GetPlanRunState() { + return GetPreviousPlan()->GetPlanRunState(); +} + +void ThreadPlanSingleThreadTimeout::TimeoutThreadFunc( + ThreadPlanSingleThreadTimeout *self) { + std::unique_lock<std::mutex> lock(self->m_mutex); + uint64_t timeout_in_ms = self->GetThread().GetSingleThreadPlanTimeout(); + self->m_wakeup_cv.wait_for(lock, std::chrono::milliseconds(timeout_in_ms), + [self] { return self->m_exit_flag; }); + + Log *log = GetLog(LLDBLog::Step); + LLDB_LOGF(log, + "ThreadPlanSingleThreadTimeout::TimeoutThreadFunc() called with " + "m_exit_flag(%d).", + self->m_exit_flag); + if (self->m_exit_flag) + return; + + self->HandleTimeout(); +} + +bool ThreadPlanSingleThreadTimeout::MischiefManaged() { + Log *log = GetLog(LLDBLog::Step); + LLDB_LOGF(log, "ThreadPlanSingleThreadTimeout::MischiefManaged() called."); + // Need to reset timer on each internal stop/execution progress. + return true; +} + +bool ThreadPlanSingleThreadTimeout::ShouldStop(Event *event_ptr) { + return HandleEvent(event_ptr); +} + +void ThreadPlanSingleThreadTimeout::SetStopOthers(bool new_value) { + GetPreviousPlan()->SetStopOthers(new_value); +} + +bool ThreadPlanSingleThreadTimeout::StopOthers() { + if (m_state == State::Done) + return false; + else + return GetPreviousPlan()->StopOthers(); +} + +bool ThreadPlanSingleThreadTimeout::HandleEvent(Event *event_ptr) { + lldb::StateType stop_state = + Process::ProcessEventData::GetStateFromEvent(event_ptr); + Log *log = GetLog(LLDBLog::Step); + LLDB_LOGF(log, "ThreadPlanSingleThreadTimeout::HandleEvent(): got event: %s.", + StateAsCString(stop_state)); + + lldb::StopInfoSP stop_info = GetThread().GetStopInfo(); + if (m_state == State::AsyncInterrupt && stop_state == lldb::eStateStopped && + stop_info && stop_info->GetStopReason() == lldb::eStopReasonInterrupt) { + if (Process::ProcessEventData::GetRestartedFromEvent(event_ptr)) { + // If we were restarted, we just need to go back up to fetch + // another event. + LLDB_LOGF(log, + "ThreadPlanSingleThreadTimeout::HandleEvent(): Got a stop and " + "restart, so we'll continue waiting."); + + } else { + LLDB_LOGF( + log, + "ThreadPlanSingleThreadTimeout::HandleEvent(): Got async interrupt " + ", so we will resume all threads."); + GetThread().GetCurrentPlan()->SetStopOthers(false); + GetPreviousPlan()->SetStopOthers(false); + m_state = State::Done; + } + } + // Should not report stop. + return false; +} + +void ThreadPlanSingleThreadTimeout::HandleTimeout() { + Log *log = GetLog(LLDBLog::Step); + LLDB_LOGF( + log, + "ThreadPlanSingleThreadTimeout::HandleTimeout() send async interrupt."); + m_state = State::AsyncInterrupt; + + // Private state thread will only send async interrupt + // in running state so no need to check state here. + m_process.SendAsyncInterrupt(&GetThread()); +} diff --git a/lldb/source/Target/ThreadPlanStepInRange.cpp b/lldb/source/Target/ThreadPlanStepInRange.cpp index 17f2100b804fd3..0c8b92f4154202 100644 --- a/lldb/source/Target/ThreadPlanStepInRange.cpp +++ b/lldb/source/Target/ThreadPlanStepInRange.cpp @@ -134,6 +134,8 @@ bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) { GetTarget().GetArchitecture().GetAddressByteSize()); LLDB_LOGF(log, "ThreadPlanStepInRange reached %s.", s.GetData()); } + if (DoPlanExplainsStop(event_ptr)) + ClearNextBranchBreakpoint(); if (IsPlanComplete()) return true; diff --git a/lldb/source/Target/ThreadPlanStepOverRange.cpp b/lldb/source/Target/ThreadPlanStepOverRange.cpp index 84f282f1de5207..6d24b5d9d7f362 100644 --- a/lldb/source/Target/ThreadPlanStepOverRange.cpp +++ b/lldb/source/Target/ThreadPlanStepOverRange.cpp @@ -15,6 +15,7 @@ #include "lldb/Target/RegisterContext.h" #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlanSingleThreadTimeout.h" #include "lldb/Target/ThreadPlanStepOut.h" #include "lldb/Target/ThreadPlanStepThrough.h" #include "lldb/Utility/LLDBLog.h" @@ -36,7 +37,8 @@ ThreadPlanStepOverRange::ThreadPlanStepOverRange( : ThreadPlanStepRange(ThreadPlan::eKindStepOverRange, "Step range stepping over", thread, range, addr_context, stop_others), - ThreadPlanShouldStopHere(this), m_first_resume(true) { + ThreadPlanShouldStopHere(this), m_first_resume(true), + m_run_mode(stop_others) { SetFlagsToDefault(); SetupAvoidNoDebug(step_out_avoids_code_without_debug_info); } @@ -124,6 +126,11 @@ bool ThreadPlanStepOverRange::IsEquivalentContext( return m_addr_context.symbol && m_addr_context.symbol == context.symbol; } +void ThreadPlanStepOverRange::SetStopOthers(bool stop_others) { + if (!stop_others) + m_stop_others = RunMode::eAllThreads; +} + bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) { Log *log = GetLog(LLDBLog::Step); Thread &thread = GetThread(); @@ -135,12 +142,17 @@ bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) { LLDB_LOGF(log, "ThreadPlanStepOverRange reached %s.", s.GetData()); } + if (DoPlanExplainsStop(event_ptr)) + ClearNextBranchBreakpoint(); + // If we're out of the range but in the same frame or in our caller's frame // then we should stop. When stepping out we only stop others if we are // forcing running one thread. bool stop_others = (m_stop_others == lldb::eOnlyThisThread); ThreadPlanSP new_plan_sp; FrameComparison frame_order = CompareCurrentFrameToStartFrame(); + LLDB_LOGF(log, "ThreadPlanStepOverRange compare frame result: %d.", + frame_order); if (frame_order == eFrameCompareOlder) { // If we're in an older frame then we should stop. @@ -411,6 +423,7 @@ bool ThreadPlanStepOverRange::DoWillResume(lldb::StateType resume_state, } } } - + if (m_run_mode == lldb::eOnlyThisThread) + ThreadPlanSingleThreadTimeout::ResetIfNeeded(GetThread()); return true; } diff --git a/lldb/source/Target/ThreadPlanStepRange.cpp b/lldb/source/Target/ThreadPlanStepRange.cpp index 998e76cb65d137..ef66bf2ff2514e 100644 --- a/lldb/source/Target/ThreadPlanStepRange.cpp +++ b/lldb/source/Target/ThreadPlanStepRange.cpp @@ -346,7 +346,9 @@ bool ThreadPlanStepRange::SetNextBranchBreakpoint() { run_to_address = instructions->GetInstructionAtIndex(branch_index)->GetAddress(); } - + if (branch_index == pc_index) + LLDB_LOGF(log, "ThreadPlanStepRange::SetNextBranchBreakpoint - skipping " + "because current is branch instruction"); if (run_to_address.IsValid()) { const bool is_internal = true; m_next_branch_bp_sp = @@ -380,7 +382,9 @@ bool ThreadPlanStepRange::SetNextBranchBreakpoint() { return true; } else return false; - } + } else + LLDB_LOGF(log, "ThreadPlanStepRange::SetNextBranchBreakpoint - skipping " + "invalid run_to_address"); } return false; } @@ -417,7 +421,6 @@ bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop( "next range breakpoint which has %" PRIu64 " constituents - explains stop: %u.", (uint64_t)num_constituents, explains_stop); - ClearNextBranchBreakpoint(); return explains_stop; } } diff --git a/lldb/test/API/functionalities/single-thread-step/Makefile b/lldb/test/API/functionalities/single-thread-step/Makefile new file mode 100644 index 00000000000000..de4ec12b13cbce --- /dev/null +++ b/lldb/test/API/functionalities/single-thread-step/Makefile @@ -0,0 +1,4 @@ +ENABLE_THREADS := YES +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/lldb/test/API/functionalities/single-thread-step/TestSingleThreadStepTimeout.py b/lldb/test/API/functionalities/single-thread-step/TestSingleThreadStepTimeout.py new file mode 100644 index 00000000000000..f734b4bbf116e5 --- /dev/null +++ b/lldb/test/API/functionalities/single-thread-step/TestSingleThreadStepTimeout.py @@ -0,0 +1,123 @@ +""" +Test that single thread step over deadlock issue can be resolved +after timeout. +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class SingleThreadStepTimeoutTestCase(TestBase): + NO_DEBUG_INFO_TESTCASE = True + + def setUp(self): + TestBase.setUp(self) + self.main_source = "main.cpp" + self.build() + + def verify_hit_correct_line(self, pattern): + target_line = line_number(self.main_source, pattern) + self.assertNotEqual(target_line, 0, "Could not find source pattern " + pattern) + cur_line = self.thread.frames[0].GetLineEntry().GetLine() + self.assertEqual( + cur_line, + target_line, + "Stepped to line %d instead of expected %d with pattern '%s'." + % (cur_line, target_line, pattern), + ) + + def step_over_deadlock_helper(self): + (target, _, self.thread, _) = lldbutil.run_to_source_breakpoint( + self, "// Set breakpoint1 here", lldb.SBFileSpec(self.main_source) + ) + + signal_main_thread_value = target.FindFirstGlobalVariable("signal_main_thread") + self.assertTrue(signal_main_thread_value.IsValid()) + + # Change signal_main_thread global variable to 1 so that worker thread loop can + # terminate and move forward to signal main thread + signal_main_thread_value.SetValueFromCString("1") + + self.thread.StepOver(lldb.eOnlyThisThread) + self.verify_hit_correct_line("// Finish step-over from breakpoint1") + + @skipIfWindows + def test_step_over_deadlock_small_timeout_fast_stepping(self): + """Test single thread step over deadlock on other threads can be resolved after timeout with small timeout and fast stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 10" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping true") + self.step_over_deadlock_helper() + + @skipIfWindows + def test_step_over_deadlock_small_timeout_slow_stepping(self): + """Test single thread step over deadlock on other threads can be resolved after timeout with small timeout and slow stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 10" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping false") + self.step_over_deadlock_helper() + + @skipIfWindows + def test_step_over_deadlock_large_timeout_fast_stepping(self): + """Test single thread step over deadlock on other threads can be resolved after timeout with large timeout and fast stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 2000" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping true") + self.step_over_deadlock_helper() + + @skipIfWindows + def test_step_over_deadlock_large_timeout_slow_stepping(self): + """Test single thread step over deadlock on other threads can be resolved after timeout with large timeout and slow stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 2000" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping false") + self.step_over_deadlock_helper() + + def step_over_multi_calls_helper(self): + (target, _, self.thread, _) = lldbutil.run_to_source_breakpoint( + self, "// Set breakpoint2 here", lldb.SBFileSpec(self.main_source) + ) + self.thread.StepOver(lldb.eOnlyThisThread) + self.verify_hit_correct_line("// Finish step-over from breakpoint2") + + @skipIfWindows + def test_step_over_deadlock_small_timeout_fast_stepping(self): + """Test step over source line with multiple call instructions works fine with small timeout and fast stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 10" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping true") + self.step_over_multi_calls_helper() + + @skipIfWindows + def test_step_over_deadlock_small_timeout_slow_stepping(self): + """Test step over source line with multiple call instructions works fine with small timeout and slow stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 10" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping false") + self.step_over_multi_calls_helper() + + @skipIfWindows + def test_step_over_deadlock_large_timeout_fast_stepping(self): + """Test step over source line with multiple call instructions works fine with large timeout and fast stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 2000" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping true") + self.step_over_multi_calls_helper() + + @skipIfWindows + def test_step_over_deadlock_large_timeout_slow_stepping(self): + """Test step over source line with multiple call instructions works fine with large timeout and slow stepping.""" + self.dbg.HandleCommand( + "settings set target.process.thread.single-thread-plan-timeout 2000" + ) + self.dbg.HandleCommand("settings set target.use-fast-stepping false") + self.step_over_multi_calls_helper() diff --git a/lldb/test/API/functionalities/single-thread-step/main.cpp b/lldb/test/API/functionalities/single-thread-step/main.cpp new file mode 100644 index 00000000000000..16356a08375b84 --- /dev/null +++ b/lldb/test/API/functionalities/single-thread-step/main.cpp @@ -0,0 +1,62 @@ +#include <condition_variable> +#include <iostream> +#include <mutex> +#include <thread> + +std::mutex mtx; +std::condition_variable cv; +int ready_thread_id = 0; +int signal_main_thread = 0; + +void worker(int id) { + std::cout << "Worker " << id << " executing..." << std::endl; + + // lldb test should change signal_main_thread to true to break the loop. + while (!signal_main_thread) { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + + // Signal the main thread to continue main thread + { + std::lock_guard<std::mutex> lock(mtx); + ready_thread_id = id; // break worker thread here + } + cv.notify_one(); + + std::this_thread::sleep_for(std::chrono::seconds(1)); + std::cout << "Worker " << id << " finished." << std::endl; +} + +int simulate_thread() { + std::thread t1(worker, 1); + + // Wait until signaled by the first thread + std::unique_lock<std::mutex> lock(mtx); + auto func = [] { return ready_thread_id == 1; }; + cv.wait(lock, func); // Set breakpoint1 here + + std::thread t2(worker, 2); // Finish step-over from breakpoint1 + + cv.wait(lock, [] { return ready_thread_id == 2; }); + + t1.join(); + t2.join(); + + std::cout << "Main thread continues..." << std::endl; + + return 0; +} + +int bar() { return 54; } + +int foo(const std::string p1, int extra) { return p1.size() + extra; } + +int main(int argc, char *argv[]) { + std::string ss = "this is a string for testing", + ls = "this is a long string for testing"; + foo(ss.size() % 2 == 0 ? ss : ls, bar()); // Set breakpoint2 here + + simulate_thread(); // Finish step-over from breakpoint2 + + return 0; +} diff --git a/lldb/tools/lldb-dap/JSONUtils.cpp b/lldb/tools/lldb-dap/JSONUtils.cpp index b4a2718bbb096e..5ff01966198293 100644 --- a/lldb/tools/lldb-dap/JSONUtils.cpp +++ b/lldb/tools/lldb-dap/JSONUtils.cpp @@ -924,6 +924,9 @@ llvm::json::Value CreateThreadStopped(lldb::SBThread &thread, case lldb::eStopReasonVForkDone: body.try_emplace("reason", "vforkdone"); break; + case lldb::eStopReasonInterrupt: + body.try_emplace("reason", "async interrupt"); + break; case lldb::eStopReasonThreadExiting: case lldb::eStopReasonInvalid: case lldb::eStopReasonNone: diff --git a/lldb/tools/lldb-dap/LLDBUtils.cpp b/lldb/tools/lldb-dap/LLDBUtils.cpp index a91cc6718f4dfc..2da107887604b4 100644 --- a/lldb/tools/lldb-dap/LLDBUtils.cpp +++ b/lldb/tools/lldb-dap/LLDBUtils.cpp @@ -110,6 +110,7 @@ bool ThreadHasStopReason(lldb::SBThread &thread) { case lldb::eStopReasonFork: case lldb::eStopReasonVFork: case lldb::eStopReasonVForkDone: + case lldb::eStopReasonInterrupt: return true; case lldb::eStopReasonThreadExiting: case lldb::eStopReasonInvalid: _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits