Author: labath
Date: Wed Nov 30 05:56:32 2016
New Revision: 288241
URL: http://llvm.org/viewvc/llvm-project?rev=288241&view=rev
Log:
Convert most of the Process class to Timeout<>
This changes most of the class to use the new Timeout class. The one function
left is RunThreadPlan, which I left for a separate change as the function is
massive. A couple of things to call out:
- I've renamed the affected functions to match the listener interface names.
This
should also help catch any places I did not convert at compile time.
- I've deleted the WaitForState function as it was unused.
Modified:
lldb/trunk/include/lldb/Target/Process.h
lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp
lldb/trunk/source/Target/Process.cpp
lldb/trunk/source/Target/Target.cpp
Modified: lldb/trunk/include/lldb/Target/Process.h
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Process.h?rev=288241&r1=288240&r2=288241&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/Process.h (original)
+++ lldb/trunk/include/lldb/Target/Process.h Wed Nov 30 05:56:32 2016
@@ -2415,7 +2415,7 @@ public:
// false
// will avoid this behavior.
lldb::StateType
- WaitForProcessToStop(const std::chrono::microseconds &timeout,
+ WaitForProcessToStop(const Timeout<std::micro> &timeout,
lldb::EventSP *event_sp_ptr = nullptr,
bool wait_always = true,
lldb::ListenerSP hijack_listener = lldb::ListenerSP(),
@@ -2436,8 +2436,8 @@ public:
//--------------------------------------------------------------------------------------
void SyncIOHandler(uint32_t iohandler_id, uint64_t timeout_msec);
- lldb::StateType WaitForStateChangedEvents(
- const std::chrono::microseconds &timeout, lldb::EventSP &event_sp,
+ lldb::StateType GetStateChangedEvents(
+ lldb::EventSP &event_sp, const Timeout<std::micro> &timeout,
lldb::ListenerSP
hijack_listener); // Pass an empty ListenerSP to use builtin listener
@@ -3105,24 +3105,19 @@ protected:
Error HaltPrivate();
- lldb::StateType
- WaitForProcessStopPrivate(const std::chrono::microseconds &timeout,
- lldb::EventSP &event_sp);
+ lldb::StateType WaitForProcessStopPrivate(lldb::EventSP &event_sp,
+ const Timeout<std::micro>
&timeout);
// This waits for both the state change broadcaster, and the control
// broadcaster.
// If control_only, it only waits for the control broadcaster.
- bool WaitForEventsPrivate(const std::chrono::microseconds &timeout,
- lldb::EventSP &event_sp, bool control_only);
+ bool GetEventsPrivate(lldb::EventSP &event_sp,
+ const Timeout<std::micro> &timeout, bool control_only);
lldb::StateType
- WaitForStateChangedEventsPrivate(const std::chrono::microseconds &timeout,
- lldb::EventSP &event_sp);
-
- lldb::StateType WaitForState(const std::chrono::microseconds &timeout,
- const lldb::StateType *match_states,
- const uint32_t num_match_states);
+ GetStateChangedEventsPrivate(lldb::EventSP &event_sp,
+ const Timeout<std::micro> &timeout);
size_t WriteMemoryPrivate(lldb::addr_t addr, const void *buf, size_t size,
Error &error);
Modified: lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp?rev=288241&r1=288240&r2=288241&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp (original)
+++ lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp Wed Nov 30
05:56:32 2016
@@ -644,7 +644,7 @@ PlatformLinux::DebugProcess(ProcessLaunc
// Handle the hijacking of process events.
if (listener_sp) {
const StateType state = process_sp->WaitForProcessToStop(
- std::chrono::microseconds(0), NULL, false, listener_sp);
+ llvm::None, NULL, false, listener_sp);
if (state == eStateStopped) {
if (log)
Modified: lldb/trunk/source/Target/Process.cpp
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Process.cpp?rev=288241&r1=288240&r2=288241&view=diff
==============================================================================
--- lldb/trunk/source/Target/Process.cpp (original)
+++ lldb/trunk/source/Target/Process.cpp Wed Nov 30 05:56:32 2016
@@ -67,6 +67,7 @@
using namespace lldb;
using namespace lldb_private;
+using namespace std::chrono;
// A temporary function to convert between old representations of timeouts (0
// means infinite wait) and new Timeout class (0 means "poll").
@@ -971,11 +972,10 @@ void Process::SyncIOHandler(uint32_t ioh
__FUNCTION__, iohandler_id, new_iohandler_id);
}
-StateType
-Process::WaitForProcessToStop(const std::chrono::microseconds &timeout,
- EventSP *event_sp_ptr, bool wait_always,
- ListenerSP hijack_listener_sp, Stream *stream,
- bool use_run_lock) {
+StateType Process::WaitForProcessToStop(const Timeout<std::micro> &timeout,
+ EventSP *event_sp_ptr, bool
wait_always,
+ ListenerSP hijack_listener_sp,
+ Stream *stream, bool use_run_lock) {
// We can't just wait for a "stopped" event, because the stopped event may
// have restarted the target.
// We have to actually check each event, and in the case of a stopped event
@@ -991,8 +991,9 @@ Process::WaitForProcessToStop(const std:
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log)
- log->Printf("Process::%s (timeout = %llu)", __FUNCTION__,
- static_cast<unsigned long long>(timeout.count()));
+ log->Printf(
+ "Process::%s (timeout = %llu)", __FUNCTION__,
+ static_cast<unsigned long long>(timeout ? timeout->count() : -1));
if (!wait_always && StateIsStoppedState(state, true) &&
StateIsStoppedState(GetPrivateState(), true)) {
@@ -1009,7 +1010,7 @@ Process::WaitForProcessToStop(const std:
while (state != eStateInvalid) {
EventSP event_sp;
- state = WaitForStateChangedEvents(timeout, event_sp, hijack_listener_sp);
+ state = GetStateChangedEvents(event_sp, timeout, hijack_listener_sp);
if (event_sp_ptr && event_sp)
*event_sp_ptr = event_sp;
@@ -1254,27 +1255,6 @@ bool Process::HandleProcessStateChangedE
return true;
}
-StateType Process::WaitForState(const std::chrono::microseconds &timeout,
- const StateType *match_states,
- const uint32_t num_match_states) {
- EventSP event_sp;
- StateType state = GetState();
- while (state != eStateInvalid) {
- // If we are exited or detached, we won't ever get back to any
- // other valid state...
- if (state == eStateDetached || state == eStateExited)
- return state;
-
- state = WaitForStateChangedEvents(timeout, event_sp, nullptr);
-
- for (uint32_t i = 0; i < num_match_states; ++i) {
- if (match_states[i] == state)
- return state;
- }
- }
- return state;
-}
-
bool Process::HijackProcessEvents(ListenerSP listener_sp) {
if (listener_sp) {
return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged |
@@ -1285,15 +1265,15 @@ bool Process::HijackProcessEvents(Listen
void Process::RestoreProcessEvents() { RestoreBroadcaster(); }
-StateType
-Process::WaitForStateChangedEvents(const std::chrono::microseconds &timeout,
- EventSP &event_sp,
- ListenerSP hijack_listener_sp) {
+StateType Process::GetStateChangedEvents(EventSP &event_sp,
+ const Timeout<std::micro> &timeout,
+ ListenerSP hijack_listener_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log)
- log->Printf("Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
- static_cast<unsigned long long>(timeout.count()));
+ log->Printf(
+ "Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
+ static_cast<unsigned long long>(timeout ? timeout->count() : -1));
ListenerSP listener_sp = hijack_listener_sp;
if (!listener_sp)
@@ -1302,7 +1282,7 @@ Process::WaitForStateChangedEvents(const
StateType state = eStateInvalid;
if (listener_sp->GetEventForBroadcasterWithType(
this, eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp,
- ConvertTimeout(timeout))) {
+ timeout)) {
if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
else if (log)
@@ -1310,9 +1290,10 @@ Process::WaitForStateChangedEvents(const
}
if (log)
- log->Printf("Process::%s (timeout = %llu, event_sp) => %s", __FUNCTION__,
- static_cast<unsigned long long>(timeout.count()),
- StateAsCString(state));
+ log->Printf(
+ "Process::%s (timeout = %llu, event_sp) => %s", __FUNCTION__,
+ static_cast<unsigned long long>(timeout ? timeout->count() : -1),
+ StateAsCString(state));
return state;
}
@@ -1337,19 +1318,21 @@ Event *Process::PeekAtStateChangedEvents
return event_ptr;
}
-StateType Process::WaitForStateChangedEventsPrivate(
- const std::chrono::microseconds &timeout, EventSP &event_sp) {
+StateType
+Process::GetStateChangedEventsPrivate(EventSP &event_sp,
+ const Timeout<std::micro> &timeout) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log)
- log->Printf("Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
- static_cast<unsigned long long>(timeout.count()));
+ log->Printf(
+ "Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
+ static_cast<unsigned long long>(timeout ? timeout->count() : -1));
StateType state = eStateInvalid;
if (m_private_state_listener_sp->GetEventForBroadcasterWithType(
&m_private_state_broadcaster,
eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp,
- ConvertTimeout(timeout)))
+ timeout))
if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
@@ -1357,27 +1340,28 @@ StateType Process::WaitForStateChangedEv
// to the command-line, and that could disable the log, which would render
the
// log we got above invalid.
if (log)
- log->Printf("Process::%s (timeout = %llu, event_sp) => %s", __FUNCTION__,
- static_cast<unsigned long long>(timeout.count()),
- state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
+ log->Printf(
+ "Process::%s (timeout = %llu, event_sp) => %s", __FUNCTION__,
+ static_cast<unsigned long long>(timeout ? timeout->count() : -1),
+ state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
return state;
}
-bool Process::WaitForEventsPrivate(const std::chrono::microseconds &timeout,
- EventSP &event_sp, bool control_only) {
+bool Process::GetEventsPrivate(EventSP &event_sp,
+ const Timeout<std::micro> &timeout,
+ bool control_only) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log)
- log->Printf("Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
- static_cast<unsigned long long>(timeout.count()));
+ log->Printf(
+ "Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
+ static_cast<unsigned long long>(timeout ? timeout->count() : -1));
if (control_only)
return m_private_state_listener_sp->GetEventForBroadcaster(
- &m_private_state_control_broadcaster, event_sp,
- ConvertTimeout(timeout));
+ &m_private_state_control_broadcaster, event_sp, timeout);
else
- return m_private_state_listener_sp->GetEvent(event_sp,
- ConvertTimeout(timeout));
+ return m_private_state_listener_sp->GetEvent(event_sp, timeout);
}
bool Process::IsRunning() const {
@@ -1688,8 +1672,8 @@ Error Process::ResumeSynchronous(Stream
Error error = PrivateResume();
if (error.Success()) {
- StateType state = WaitForProcessToStop(std::chrono::microseconds(0), NULL,
- true, listener_sp, stream);
+ StateType state =
+ WaitForProcessToStop(llvm::None, NULL, true, listener_sp, stream);
const bool must_be_alive =
false; // eStateExited is ok, so this must be false
if (!StateIsStoppedState(state, must_be_alive))
@@ -2718,14 +2702,14 @@ Error Process::DisableWatchpoint(Watchpo
}
StateType
-Process::WaitForProcessStopPrivate(const std::chrono::microseconds &timeout,
- EventSP &event_sp) {
+Process::WaitForProcessStopPrivate(EventSP &event_sp,
+ const Timeout<std::micro> &timeout) {
StateType state;
// Now wait for the process to launch and return control to us, and then
// call DidLaunch:
while (true) {
event_sp.reset();
- state = WaitForStateChangedEventsPrivate(timeout, event_sp);
+ state = GetStateChangedEventsPrivate(event_sp, timeout);
if (StateIsStoppedState(state, false))
break;
@@ -2801,8 +2785,7 @@ Error Process::Launch(ProcessLaunchInfo
}
} else {
EventSP event_sp;
- StateType state =
- WaitForProcessStopPrivate(std::chrono::seconds(10), event_sp);
+ StateType state = WaitForProcessStopPrivate(event_sp, seconds(10));
if (state == eStateInvalid || !event_sp) {
// We were able to launch the process, but we failed to
@@ -3271,8 +3254,7 @@ Error Process::ConnectRemote(Stream *str
if (error.Success()) {
if (GetID() != LLDB_INVALID_PROCESS_ID) {
EventSP event_sp;
- StateType state =
- WaitForProcessStopPrivate(std::chrono::microseconds(0), event_sp);
+ StateType state = WaitForProcessStopPrivate(event_sp, llvm::None);
if (state == eStateStopped || state == eStateCrashed) {
// If we attached and actually have a process on the other end, then
@@ -3374,9 +3356,8 @@ Error Process::Halt(bool clear_thread_pl
}
// Wait for 10 second for the process to stop.
- StateType state =
- WaitForProcessToStop(std::chrono::seconds(10), &event_sp, true,
- halt_listener_sp, nullptr, use_run_lock);
+ StateType state = WaitForProcessToStop(
+ seconds(10), &event_sp, true, halt_listener_sp, nullptr, use_run_lock);
RestoreProcessEvents();
if (state == eStateInvalid || !event_sp) {
@@ -3408,8 +3389,8 @@ Error Process::StopForDestroyOrDetach(ll
SendAsyncInterrupt();
// Consume the interrupt event.
- StateType state = WaitForProcessToStop(std::chrono::seconds(10),
- &exit_event_sp, true, listener_sp);
+ StateType state =
+ WaitForProcessToStop(seconds(10), &exit_event_sp, true, listener_sp);
RestoreProcessEvents();
@@ -4038,7 +4019,7 @@ thread_result_t Process::RunPrivateState
bool interrupt_requested = false;
while (!exit_now) {
EventSP event_sp;
- WaitForEventsPrivate(std::chrono::microseconds(0), event_sp, control_only);
+ GetEventsPrivate(event_sp, llvm::None, control_only);
if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) {
if (log)
log->Printf("Process::%s (arg = %p, pid = %" PRIu64
Modified: lldb/trunk/source/Target/Target.cpp
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Target.cpp?rev=288241&r1=288240&r2=288241&view=diff
==============================================================================
--- lldb/trunk/source/Target/Target.cpp (original)
+++ lldb/trunk/source/Target/Target.cpp Wed Nov 30 05:56:32 2016
@@ -2907,8 +2907,7 @@ Error Target::Launch(ProcessLaunchInfo &
}
StateType state = m_process_sp->WaitForProcessToStop(
- std::chrono::microseconds(0), nullptr, false, hijack_listener_sp,
- nullptr);
+ llvm::None, nullptr, false, hijack_listener_sp, nullptr);
if (state == eStateStopped) {
if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) {
@@ -2916,8 +2915,7 @@ Error Target::Launch(ProcessLaunchInfo &
error = m_process_sp->PrivateResume();
if (error.Success()) {
state = m_process_sp->WaitForProcessToStop(
- std::chrono::microseconds(0), nullptr, true,
- hijack_listener_sp, stream);
+ llvm::None, nullptr, true, hijack_listener_sp, stream);
const bool must_be_alive =
false; // eStateExited is ok, so this must be false
if (!StateIsStoppedState(state, must_be_alive)) {
@@ -3041,8 +3039,7 @@ Error Target::Attach(ProcessAttachInfo &
process_sp->RestoreProcessEvents();
} else {
state = process_sp->WaitForProcessToStop(
- std::chrono::microseconds(0), nullptr, false,
- attach_info.GetHijackListener(), stream);
+ llvm::None, nullptr, false, attach_info.GetHijackListener(), stream);
process_sp->RestoreProcessEvents();
if (state != eStateStopped) {
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
