LLDB  mainline
ScriptedProcess.cpp
Go to the documentation of this file.
1 //===-- ScriptedProcess.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "ScriptedProcess.h"
10 
11 #include "lldb/Core/Debugger.h"
12 #include "lldb/Core/Module.h"
14 
15 #include "lldb/Host/OptionParser.h"
23 #include "lldb/Utility/State.h"
24 
25 #include <mutex>
26 
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 llvm::StringRef ScriptedProcess::GetPluginDescriptionStatic() {
33  return "Scripted Process plug-in.";
34 }
35 
38 };
39 
40 bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) {
41  llvm::ArrayRef<lldb::ScriptLanguage> supported_languages =
42  llvm::makeArrayRef(g_supported_script_languages);
43 
44  return llvm::is_contained(supported_languages, language);
45 }
46 
47 void ScriptedProcess::CheckInterpreterAndScriptObject() const {
48  lldbassert(m_interpreter && "Invalid Script Interpreter.");
49  lldbassert(m_script_object_sp && "Invalid Script Object.");
50 }
51 
52 lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
53  lldb::ListenerSP listener_sp,
54  const FileSpec *file,
55  bool can_connect) {
56  if (!target_sp ||
57  !IsScriptLanguageSupported(target_sp->GetDebugger().GetScriptLanguage()))
58  return nullptr;
59 
60  Status error;
61  ScriptedProcess::ScriptedProcessInfo scripted_process_info(
62  target_sp->GetProcessLaunchInfo());
63 
64  auto process_sp = std::make_shared<ScriptedProcess>(
65  target_sp, listener_sp, scripted_process_info, error);
66 
67  if (error.Fail() || !process_sp || !process_sp->m_script_object_sp ||
68  !process_sp->m_script_object_sp->IsValid()) {
70  error.AsCString());
71  return nullptr;
72  }
73 
74  return process_sp;
75 }
76 
77 bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
78  bool plugin_specified_by_name) {
79  return true;
80 }
81 
82 ScriptedProcess::ScriptedProcess(
83  lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
84  const ScriptedProcess::ScriptedProcessInfo &scripted_process_info,
85  Status &error)
86  : Process(target_sp, listener_sp),
87  m_scripted_process_info(scripted_process_info) {
88 
89  if (!target_sp) {
90  error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
91  __FUNCTION__, "Invalid target");
92  return;
93  }
94 
95  m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
96 
97  if (!m_interpreter) {
98  error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
99  __FUNCTION__,
100  "Debugger has no Script Interpreter");
101  return;
102  }
103 
104  ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
105 
107  m_scripted_process_info.GetClassName().c_str(), exe_ctx,
109 
110  if (!object_sp || !object_sp->IsValid()) {
111  error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
112  __FUNCTION__,
113  "Failed to create valid script object");
114  return;
115  }
116 
117  m_script_object_sp = object_sp;
118 }
119 
121  Clear();
122  // We need to call finalize on the process before destroying ourselves to
123  // make sure all of the broadcaster cleanup goes as planned. If we destruct
124  // this class, then Process::~Process() might have problems trying to fully
125  // destroy the broadcaster.
126  Finalize();
127 }
128 
130  static llvm::once_flag g_once_flag;
131 
132  llvm::call_once(g_once_flag, []() {
135  });
136 }
137 
140 }
141 
144 
145  return DoLaunch(nullptr, launch_info);
146 }
147 
149  ProcessLaunchInfo &launch_info) {
151 
152  /* FIXME: This doesn't reflect how lldb actually launches a process.
153  In reality, it attaches to debugserver, then resume the process. */
156 
157  if (error.Fail())
158  return error;
159 
160  // TODO: Fetch next state from stopped event queue then send stop event
161  // const StateType state = SetThreadStopInfo(response);
162  // if (state != eStateInvalid) {
163  // SetPrivateState(state);
164 
166 
167  return {};
168 }
169 
173 }
174 
177 
179  // FIXME: Fetch data from thread.
180  const StateType thread_resume_state = eStateRunning;
181  LLDB_LOGF(log, "ScriptedProcess::%s thread_resume_state = %s", __FUNCTION__,
182  StateAsCString(thread_resume_state));
183 
184  bool resume = (thread_resume_state == eStateRunning);
185  assert(thread_resume_state == eStateRunning && "invalid thread resume state");
186 
187  Status error;
188  if (resume) {
189  LLDB_LOGF(log, "ScriptedProcess::%s sending resume", __FUNCTION__);
190 
193  error = GetInterface().Resume();
194  }
195 
196  return error;
197 }
198 
201 
203 
204  if (GetInterface().ShouldStop()) {
206  LLDB_LOGF(log, "ScriptedProcess::%s Immediate stop", __FUNCTION__);
207  return {};
208  }
209 
210  LLDB_LOGF(log, "ScriptedProcess::%s Delayed stop", __FUNCTION__);
211  return GetInterface().Stop();
212 }
213 
215 
218  return GetInterface().IsAlive();
219  return false;
220 }
221 
222 size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
223  Status &error) {
224  if (!m_interpreter)
225  return ScriptedInterface::ErrorWithMessage<size_t>(
226  LLVM_PRETTY_FUNCTION, "No interpreter.", error);
227 
228  lldb::DataExtractorSP data_extractor_sp =
229  GetInterface().ReadMemoryAtAddress(addr, size, error);
230 
231  if (!data_extractor_sp || !data_extractor_sp->GetByteSize() || error.Fail())
232  return 0;
233 
234  offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
235  0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder());
236 
237  if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
238  return ScriptedInterface::ErrorWithMessage<size_t>(
239  LLVM_PRETTY_FUNCTION, "Failed to copy read memory to buffer.", error);
240 
241  return size;
242 }
243 
245  return GetTarget().GetArchitecture();
246 }
247 
249  MemoryRegionInfo &region) {
251 
252  Status error;
253  if (auto region_or_err =
254  GetInterface().GetMemoryRegionContainingAddress(load_addr, error))
255  region = *region_or_err;
256 
257  return error;
258 }
259 
262 
263  Status error;
264  lldb::addr_t address = 0;
265 
266  while (auto region_or_err =
267  GetInterface().GetMemoryRegionContainingAddress(address, error)) {
268  if (error.Fail())
269  break;
270 
271  MemoryRegionInfo &mem_region = *region_or_err;
272  auto range = mem_region.GetRange();
273  address += range.GetRangeBase() + range.GetByteSize();
274  region_list.push_back(mem_region);
275  }
276 
277  return error;
278 }
279 
281 
283  ThreadList &new_thread_list) {
284  // TODO: Implement
285  // This is supposed to get the current set of threads, if any of them are in
286  // old_thread_list then they get copied to new_thread_list, and then any
287  // actually new threads will get added to new_thread_list.
288 
291 
292  Status error;
294 
295  if (language != eScriptLanguagePython)
296  return ScriptedInterface::ErrorWithMessage<bool>(
297  LLVM_PRETTY_FUNCTION,
298  llvm::Twine("ScriptInterpreter language (" +
299  llvm::Twine(m_interpreter->LanguageToString(language)) +
300  llvm::Twine(") not supported."))
301  .str(),
302  error);
303 
305 
306  if (!thread_info_sp)
307  return ScriptedInterface::ErrorWithMessage<bool>(
308  LLVM_PRETTY_FUNCTION,
309  "Couldn't fetch thread list from Scripted Process.", error);
310 
311  auto create_scripted_thread =
312  [this, &old_thread_list, &error,
313  &new_thread_list](ConstString key, StructuredData::Object *val) -> bool {
314  if (!val)
315  return ScriptedInterface::ErrorWithMessage<bool>(
316  LLVM_PRETTY_FUNCTION, "Invalid thread info object", error);
317 
319  if (!llvm::to_integer(key.AsCString(), tid))
320  return ScriptedInterface::ErrorWithMessage<bool>(
321  LLVM_PRETTY_FUNCTION, "Invalid thread id", error);
322 
323  if (ThreadSP thread_sp =
324  old_thread_list.FindThreadByID(tid, false /*=can_update*/)) {
325  // If the thread was already in the old_thread_list,
326  // just add it back to the new_thread_list.
327  new_thread_list.AddThread(thread_sp);
328  return true;
329  }
330 
331  auto thread_or_error = ScriptedThread::Create(*this, val->GetAsGeneric());
332 
333  if (!thread_or_error)
334  return ScriptedInterface::ErrorWithMessage<bool>(
335  LLVM_PRETTY_FUNCTION, toString(thread_or_error.takeError()), error);
336 
337  ThreadSP thread_sp = thread_or_error.get();
338  lldbassert(thread_sp && "Couldn't initialize scripted thread.");
339 
340  RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
341  if (!reg_ctx_sp)
342  return ScriptedInterface::ErrorWithMessage<bool>(
343  LLVM_PRETTY_FUNCTION,
344  llvm::Twine("Invalid Register Context for thread " +
345  llvm::Twine(key.AsCString()))
346  .str(),
347  error);
348 
349  new_thread_list.AddThread(thread_sp);
350 
351  return true;
352  };
353 
354  thread_info_sp->ForEach(create_scripted_thread);
355 
356  return new_thread_list.GetSize(false) > 0;
357 }
358 
360  // Let all threads recover from stopping and do any clean up based on the
361  // previous thread state (if any).
362 }
363 
365  info.Clear();
366  info.SetProcessID(GetID());
368  lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
369  if (module_sp) {
370  const bool add_exe_file_as_first_arg = false;
371  info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
372  add_exe_file_as_first_arg);
373  }
374  return true;
375 }
376 
379 }
lldb_private::toString
const char * toString(AppleArm64ExceptionClass EC)
Definition: AppleArm64ExceptionClass.h:38
lldb_private::ProcessInstanceInfo
Definition: ProcessInfo.h:108
lldb_private::Range::GetRangeBase
BaseType GetRangeBase() const
Definition: RangeMap.h:46
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb::ScriptLanguage
ScriptLanguage
Script interpreter types.
Definition: lldb-enumerations.h:216
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb_private::Process::m_thread_list
ThreadList m_thread_list
The threads for this process as the user will see them.
Definition: Process.h:2861
lldb_private::ProcessInfo::SetExecutableFile
void SetExecutableFile(const FileSpec &exe_file, bool add_exe_file_as_first_arg)
Definition: ProcessInfo.cpp:62
lldb_private::ProcessInfo::SetArchitecture
void SetArchitecture(const ArchSpec &arch)
Definition: ProcessInfo.h:65
lldb_private::ProcessInstanceInfo::Clear
void Clear()
Definition: ProcessInfo.h:116
lldb_private::StructuredData::GenericSP
std::shared_ptr< Generic > GenericSP
Definition: StructuredData.h:68
lldb_private::ScriptedProcessInterface::CreatePluginObject
StructuredData::GenericSP CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx, StructuredData::DictionarySP args_sp, StructuredData::Generic *script_obj=nullptr) override
Definition: ScriptedProcessInterface.h:25
lldb_private::ScriptedProcess::GetInterface
ScriptedProcessInterface & GetInterface() const
Definition: ScriptedProcess.cpp:377
lldb_private::ScriptedProcess::CreateInstance
static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file_path, bool can_connect)
Definition: ScriptedProcess.cpp:52
lldb_private::ScriptedProcess::DoDestroy
Status DoDestroy() override
Definition: ScriptedProcess.cpp:214
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:283
lldb_private::Process
Definition: Process.h:338
lldb_private::ScriptedProcess::DoLoadCore
Status DoLoadCore() override
Definition: ScriptedProcess.cpp:142
lldb_private::Target::GetExecutableModule
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1344
Module.h
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1206
lldb_private::StateAsCString
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
lldb_private::Module
Definition: Module.h:85
OptionArgParser.h
lldb_private::ScriptedProcess::GetPluginNameStatic
static llvm::StringRef GetPluginNameStatic()
Definition: ScriptedProcess.h:49
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::MemoryRegionInfo
Definition: MemoryRegionInfo.h:21
lldb_private::ProcessInfo::SetProcessID
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:69
lldb_private::ThreadPlanStackMap::ClearThreadCache
void ClearThreadCache()
Clear the Thread* cache that each ThreadPlan contains.
Definition: ThreadPlanStack.h:151
lldb_private::ScriptedProcess::DoUpdateThreadList
bool DoUpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list) override
Update the thread list following process plug-in's specific logic.
Definition: ScriptedProcess.cpp:282
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::Process::SetPrivateState
void SetPrivateState(lldb::StateType state)
Definition: Process.cpp:1415
lldb_private::ScriptedProcess::GetProcessInfo
bool GetProcessInfo(ProcessInstanceInfo &info) override
Definition: ScriptedProcess.cpp:364
lldb_private::ScriptedProcess::DidLaunch
void DidLaunch() override
Called after launching a process.
Definition: ScriptedProcess.cpp:170
lldb_private::ScriptInterpreter::GetScriptedProcessInterface
ScriptedProcessInterface & GetScriptedProcessInterface()
Definition: ScriptInterpreter.h:561
ThreadLauncher.h
Debugger.h
lldb_private::ScriptedProcess::GetPluginDescriptionStatic
static llvm::StringRef GetPluginDescriptionStatic()
Definition: ScriptedProcess.cpp:32
lldb_private::ScriptedProcess::Clear
void Clear()
Definition: ScriptedProcess.cpp:280
lldb_private::ScriptedProcess::DoReadMemory
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size, Status &error) override
Actually do the reading of memory from a process.
Definition: ScriptedProcess.cpp:222
lldb::eStateStopped
@ eStateStopped
Process or thread is stopped and can be examined.
Definition: lldb-enumerations.h:84
lldb_private::ScriptInterpreter::GetLanguage
lldb::ScriptLanguage GetLanguage()
Definition: ScriptInterpreter.h:559
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::ThreadList::Clear
void Clear()
Definition: ThreadList.cpp:443
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Process::m_pid
lldb::pid_t m_pid
Definition: Process.h:2831
lldb_private::ScriptedProcessInterface::GetProcessID
virtual lldb::pid_t GetProcessID()
Definition: ScriptedProcessInterface.h:62
lldb_private::PluginManager::UnregisterPlugin
static bool UnregisterPlugin(ABICreateInstance create_callback)
Definition: PluginManager.cpp:293
lldb_private::ScriptedProcess::RefreshStateAfterStop
void RefreshStateAfterStop() override
Currently called as part of ShouldStop.
Definition: ScriptedProcess.cpp:359
lldb_private::ThreadList::FindThreadByID
lldb::ThreadSP FindThreadByID(lldb::tid_t tid, bool can_update=true)
Definition: ThreadList.cpp:102
LLDB_INVALID_OFFSET
#define LLDB_INVALID_OFFSET
Definition: lldb-defines.h:85
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
MemoryRegionInfo.h
ScriptedProcess.h
lldb_private::ScriptedProcessInterface::ReadMemoryAtAddress
virtual lldb::DataExtractorSP ReadMemoryAtAddress(lldb::addr_t address, size_t size, Status &error)
Definition: ScriptedProcessInterface.h:56
lldb_private::ScriptedProcessInterface::GetThreadsInfo
virtual StructuredData::DictionarySP GetThreadsInfo()
Definition: ScriptedProcessInterface.h:45
lldb_private::MemoryRegionInfos
Definition: MemoryRegionInfo.h:164
lldb_private::ScriptedProcess::GetArchitecture
ArchSpec GetArchitecture()
Definition: ScriptedProcess.cpp:244
lldb_private::Process::Finalize
virtual void Finalize()
This object is about to be destroyed, do any necessary cleanup.
Definition: Process.cpp:510
lldb_private::ThreadList
Definition: ThreadList.h:26
lldb_private::ConstString
Definition: ConstString.h:40
lldb::eScriptLanguagePython
@ eScriptLanguagePython
Definition: lldb-enumerations.h:218
lldb_private::ScriptedProcessInterface::Launch
virtual Status Launch()
Definition: ScriptedProcessInterface.h:31
lldb_private::ScriptedProcess::m_script_object_sp
lldb_private::StructuredData::ObjectSP m_script_object_sp
Definition: ScriptedProcess.h:113
lldb_private::ScriptedProcessInterface::Resume
virtual Status Resume()
Definition: ScriptedProcessInterface.h:33
lldb_private::StructuredData::DictionarySP
std::shared_ptr< Dictionary > DictionarySP
Definition: StructuredData.h:67
lldb_private::ScriptedProcess::Initialize
static void Initialize()
Definition: ScriptedProcess.cpp:129
lldb_private::ScriptedProcess::Terminate
static void Terminate()
Definition: ScriptedProcess.cpp:138
lldb_private::ScriptedProcess::ScriptedProcessInfo::GetClassName
std::string GetClassName() const
Definition: ScriptedProcess.h:31
lldb_private::TargetProperties::GetProcessLaunchInfo
const ProcessLaunchInfo & GetProcessLaunchInfo() const
Definition: Target.cpp:4335
lldb_private::ScriptedProcessInterface::IsAlive
virtual bool IsAlive()
Definition: ScriptedProcessInterface.h:64
lldbassert
#define lldbassert(x)
Definition: LLDBAssert.h:15
lldb_private::ScriptedProcess::m_scripted_process_info
const ScriptedProcessInfo m_scripted_process_info
Definition: ScriptedProcess.h:111
lldb_private::Target::GetArchitecture
const ArchSpec & GetArchitecture() const
Definition: Target.h:968
lldb_private::ScriptedThread::Create
static llvm::Expected< std::shared_ptr< ScriptedThread > > Create(ScriptedProcess &process, StructuredData::Generic *script_object=nullptr)
Definition: ScriptedThread.cpp:32
lldb_private::Status
Definition: Status.h:44
lldb_private::ScriptedProcessInterface::Stop
virtual Status Stop()
Definition: ScriptedProcessInterface.h:37
lldb_private::ScriptedProcessInterface
Definition: ScriptedProcessInterface.h:22
lldb_private::ScriptedProcess::~ScriptedProcess
~ScriptedProcess() override
Definition: ScriptedProcess.cpp:120
lldb_private::ScriptedProcess
Definition: ScriptedProcess.h:22
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(LLDBLog mask)
Definition: Logging.cpp:83
lldb_private::ThreadList::GetSize
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:82
lldb_private::ScriptedProcess::IsAlive
bool IsAlive() override
Check if a process is still alive.
Definition: ScriptedProcess.cpp:216
lldb_private::ScriptInterpreter::LanguageToString
static std::string LanguageToString(lldb::ScriptLanguage language)
Definition: ScriptInterpreter.cpp:63
lldb_private::ScriptedProcess::DoLaunch
Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override
Launch a new process.
Definition: ScriptedProcess.cpp:148
PluginManager.h
lldb_private::ScriptedProcess::GetMemoryRegionInfo
Status GetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info) override
Locate the memory region that contains load_addr.
Definition: ScriptedProcess.cpp:248
lldb_private::Process::GetID
lldb::pid_t GetID() const
Returns the pid of the process or LLDB_INVALID_PROCESS_ID if there is no known pid.
Definition: Process.h:538
lldb_private::MemoryRegionInfo::GetRange
RangeType & GetRange()
Definition: MemoryRegionInfo.h:36
lldb_private::Process::m_thread_plans
ThreadPlanStackMap m_thread_plans
This is the list of thread plans for threads in m_thread_list, as well as threads we knew existed,...
Definition: Process.h:2865
lldb_private::ScriptedProcess::DoResume
Status DoResume() override
Resumes all of a process's threads as configured using the Thread run control functions.
Definition: ScriptedProcess.cpp:175
lldb_private::PluginManager::RegisterPlugin
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
Definition: PluginManager.cpp:287
g_supported_script_languages
static constexpr lldb::ScriptLanguage g_supported_script_languages[]
Definition: ScriptedProcess.cpp:36
OptionParser.h
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
CommandInterpreter.h
State.h
lldb_private::ThreadCollection::AddThread
void AddThread(const lldb::ThreadSP &thread_sp)
Definition: ThreadCollection.cpp:24
OptionGroupBoolean.h
LLDB_INVALID_THREAD_ID
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:82
lldb_private::ScriptedProcess::ScriptedProcessInfo::GetArgsSP
StructuredData::DictionarySP GetArgsSP() const
Definition: ScriptedProcess.h:32
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::Process::GetByteOrder
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3302
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::Log
Definition: Log.h:48
lldb_private::ScriptedProcess::GetMemoryRegions
Status GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) override
Obtain all the mapped memory regions within this process.
Definition: ScriptedProcess.cpp:260
lldb_private::ScriptedProcess::DoStop
Status DoStop()
Definition: ScriptedProcess.cpp:199
ScriptInterpreter.h
lldb_private::ScriptedProcess::ScriptedProcessInfo
Definition: ScriptedProcess.h:24
lldb_private::ScriptedProcess::CheckInterpreterAndScriptObject
void CheckInterpreterAndScriptObject() const
Definition: ScriptedProcess.cpp:47
lldb_private::StructuredData::Object
Definition: StructuredData.h:70
lldb
Definition: SBAddress.h:15
LIBLLDB_LOG_PROCESS
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:56
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:85
RegisterContext.h
lldb_private::ScriptedProcess::m_interpreter
lldb_private::ScriptInterpreter * m_interpreter
Definition: ScriptedProcess.h:112
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86