maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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.

llvm-svn: 288241
This commit is contained in:
Pavel Labath 2016-11-30 11:56:32 +00:00
parent b099d16516
commit e3e21cfc0c
4 changed files with 64 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
lldb/include/lldb/Target/Process.h
View File

@ -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);

2
lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp
View File

@ -644,7 +644,7 @@ PlatformLinux::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
// 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)

121
lldb/source/Target/Process.cpp
View File

@ -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 iohandler_id, uint64_t timeout_msec) {
__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::chrono::microseconds &timeout,
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::chrono::microseconds &timeout,
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::HandleProcessStateChangedEvent(const EventSP &event_sp,
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(ListenerSP listener_sp) {
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 std::chrono::microseconds &timeout,
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 std::chrono::microseconds &timeout,
}
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::WaitForStateChangedEventsPrivate(
// 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 *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(Watchpoint *watchpoint, bool notify) {
}
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 &launch_info) {
}
} 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 *strm, llvm::StringRef remote_url) {
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_plans, bool use_run_lock) {
}
// 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(lldb::EventSP &exit_event_sp) {
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::RunPrivateStateThread(bool is_secondary_thread) {
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

9
lldb/source/Target/Target.cpp
View File

@ -2907,8 +2907,7 @@ Error Target::Launch(ProcessLaunchInfo &launch_info, Stream *stream) {
}
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 &launch_info, Stream *stream) {
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 &attach_info, Stream *stream) {
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) {