blob: 036ce1ebccd59049dee64d2216201ee8077f2a58 [file] [log] [blame]
//===-- Debug.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 liblldb_Debug_h_
#define liblldb_Debug_h_
#include <vector>
#include "lldb/lldb-private.h"
namespace lldb_private {
// Tells a thread what it needs to do when the process is resumed.
struct ResumeAction {
lldb::tid_t tid; // The thread ID that this action applies to,
// LLDB_INVALID_THREAD_ID for the default thread
// action
lldb::StateType state; // Valid values are eStateStopped/eStateSuspended,
// eStateRunning, and eStateStepping.
int signal; // When resuming this thread, resume it with this signal if this
// value is > 0
};
// A class that contains instructions for all threads for
// NativeProcessProtocol::Resume(). Each thread can either run, stay suspended,
// or step when the process is resumed. We optionally have the ability to also
// send a signal to the thread when the action is run or step.
class ResumeActionList {
public:
ResumeActionList() : m_actions(), m_signal_handled() {}
ResumeActionList(lldb::StateType default_action, int signal)
: m_actions(), m_signal_handled() {
SetDefaultThreadActionIfNeeded(default_action, signal);
}
ResumeActionList(const ResumeAction *actions, size_t num_actions)
: m_actions(), m_signal_handled() {
if (actions && num_actions) {
m_actions.assign(actions, actions + num_actions);
m_signal_handled.assign(num_actions, false);
}
}
~ResumeActionList() = default;
bool IsEmpty() const { return m_actions.empty(); }
void Append(const ResumeAction &action) {
m_actions.push_back(action);
m_signal_handled.push_back(false);
}
void AppendAction(lldb::tid_t tid, lldb::StateType state, int signal = 0) {
ResumeAction action = {tid, state, signal};
Append(action);
}
void AppendResumeAll() {
AppendAction(LLDB_INVALID_THREAD_ID, lldb::eStateRunning);
}
void AppendSuspendAll() {
AppendAction(LLDB_INVALID_THREAD_ID, lldb::eStateStopped);
}
void AppendStepAll() {
AppendAction(LLDB_INVALID_THREAD_ID, lldb::eStateStepping);
}
const ResumeAction *GetActionForThread(lldb::tid_t tid,
bool default_ok) const {
const size_t num_actions = m_actions.size();
for (size_t i = 0; i < num_actions; ++i) {
if (m_actions[i].tid == tid)
return &m_actions[i];
}
if (default_ok && tid != LLDB_INVALID_THREAD_ID)
return GetActionForThread(LLDB_INVALID_THREAD_ID, false);
return nullptr;
}
size_t NumActionsWithState(lldb::StateType state) const {
size_t count = 0;
const size_t num_actions = m_actions.size();
for (size_t i = 0; i < num_actions; ++i) {
if (m_actions[i].state == state)
++count;
}
return count;
}
bool SetDefaultThreadActionIfNeeded(lldb::StateType action, int signal) {
if (GetActionForThread(LLDB_INVALID_THREAD_ID, true) == nullptr) {
// There isn't a default action so we do need to set it.
ResumeAction default_action = {LLDB_INVALID_THREAD_ID, action, signal};
m_actions.push_back(default_action);
m_signal_handled.push_back(false);
return true; // Return true as we did add the default action
}
return false;
}
void SetSignalHandledForThread(lldb::tid_t tid) const {
if (tid != LLDB_INVALID_THREAD_ID) {
const size_t num_actions = m_actions.size();
for (size_t i = 0; i < num_actions; ++i) {
if (m_actions[i].tid == tid)
m_signal_handled[i] = true;
}
}
}
const ResumeAction *GetFirst() const { return m_actions.data(); }
size_t GetSize() const { return m_actions.size(); }
void Clear() {
m_actions.clear();
m_signal_handled.clear();
}
protected:
std::vector<ResumeAction> m_actions;
mutable std::vector<bool> m_signal_handled;
};
struct ThreadStopInfo {
lldb::StopReason reason;
union {
// eStopReasonSignal
struct {
uint32_t signo;
} signal;
// eStopReasonException
struct {
uint64_t type;
uint32_t data_count;
lldb::addr_t data[8];
} exception;
} details;
};
}
#endif // liblldb_Debug_h_