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
22#include "lldb/Target/Queue.h"
26#include "lldb/Utility/State.h"
27
28#include <mutex>
29
31
32using namespace lldb;
33using namespace lldb_private;
34
36 return "Scripted Process plug-in.";
37}
38
40 ScriptLanguage::eScriptLanguagePython,
41};
42
44 llvm::ArrayRef<lldb::ScriptLanguage> supported_languages =
45 llvm::ArrayRef(g_supported_script_languages);
46
47 return llvm::is_contained(supported_languages, language);
48}
49
51 lldb::ListenerSP listener_sp,
52 const FileSpec *file,
53 bool can_connect) {
54 if (!target_sp ||
55 !IsScriptLanguageSupported(target_sp->GetDebugger().GetScriptLanguage()))
56 return nullptr;
57
58 ScriptedMetadata scripted_metadata(target_sp->GetProcessLaunchInfo());
59
61 auto process_sp = std::shared_ptr<ScriptedProcess>(
62 new ScriptedProcess(target_sp, listener_sp, scripted_metadata, error));
63
64 if (error.Fail() || !process_sp || !process_sp->m_interface_up) {
65 LLDB_LOGF(GetLog(LLDBLog::Process), "%s", error.AsCString());
66 return nullptr;
67 }
68
69 return process_sp;
70}
71
73 bool plugin_specified_by_name) {
74 return true;
75}
76
78 lldb::ListenerSP listener_sp,
79 const ScriptedMetadata &scripted_metadata,
81 : Process(target_sp, listener_sp), m_scripted_metadata(scripted_metadata) {
82
83 if (!target_sp) {
84 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
85 __FUNCTION__, "Invalid target");
86 return;
87 }
88
89 ScriptInterpreter *interpreter =
90 target_sp->GetDebugger().GetScriptInterpreter();
91
92 if (!interpreter) {
93 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
94 __FUNCTION__,
95 "Debugger has no Script Interpreter");
96 return;
97 }
98
99 // Create process instance interface
101 if (!m_interface_up) {
102 error.SetErrorStringWithFormat(
103 "ScriptedProcess::%s () - ERROR: %s", __FUNCTION__,
104 "Script interpreter couldn't create Scripted Process Interface");
105 return;
106 }
107
108 ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
109
110 // Create process script object
111 auto obj_or_err = GetInterface().CreatePluginObject(
114
115 if (!obj_or_err) {
116 llvm::consumeError(obj_or_err.takeError());
117 error.SetErrorString("Failed to create script object.");
118 return;
119 }
120
121 StructuredData::GenericSP object_sp = *obj_or_err;
122
123 if (!object_sp || !object_sp->IsValid()) {
124 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
125 __FUNCTION__,
126 "Failed to create valid script object");
127 return;
128 }
129}
130
132 Clear();
133 // If the interface is not valid, we can't call Finalize(). When that happens
134 // it means that the Scripted Process instanciation failed and the
135 // CreateProcess function returns a nullptr, so no one besides this class
136 // should have access to that bogus process object.
137 if (!m_interface_up)
138 return;
139 // We need to call finalize on the process before destroying ourselves to
140 // make sure all of the broadcaster cleanup goes as planned. If we destruct
141 // this class, then Process::~Process() might have problems trying to fully
142 // destroy the broadcaster.
143 Finalize(true /* destructing */);
144}
145
147 static llvm::once_flag g_once_flag;
148
149 llvm::call_once(g_once_flag, []() {
152 });
153}
154
157}
158
161
162 return DoLaunch(nullptr, launch_info);
163}
164
166 ProcessLaunchInfo &launch_info) {
167 LLDB_LOGF(GetLog(LLDBLog::Process), "ScriptedProcess::%s launching process", __FUNCTION__);
168
169 /* MARK: This doesn't reflect how lldb actually launches a process.
170 In reality, it attaches to debugserver, then resume the process.
171 That's not true in all cases. If debugserver is remote, lldb
172 asks debugserver to launch the process for it. */
175 return error;
176}
177
179
181 // Update the PID again, in case the user provided a placeholder pid at launch
183}
184
186 LLDB_LOGF(GetLog(LLDBLog::Process), "ScriptedProcess::%s resuming process", __FUNCTION__);
187
188 return GetInterface().Resume();
189}
190
192 Status error = GetInterface().Attach(attach_info);
195 if (error.Fail())
196 return error;
197 // NOTE: We need to set the PID before finishing to attach otherwise we will
198 // hit an assert when calling the attach completion handler.
199 DidLaunch();
200
201 return {};
202}
203
204Status
206 const ProcessAttachInfo &attach_info) {
207 return DoAttach(attach_info);
208}
209
211 const char *process_name, const ProcessAttachInfo &attach_info) {
212 return DoAttach(attach_info);
213}
214
216 process_arch = GetArchitecture();
217}
218
220
222
223size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
224 Status &error) {
225 lldb::DataExtractorSP data_extractor_sp =
227
228 if (!data_extractor_sp || !data_extractor_sp->GetByteSize() || error.Fail())
229 return 0;
230
231 offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
232 0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder());
233
234 if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
235 return ScriptedInterface::ErrorWithMessage<size_t>(
236 LLVM_PRETTY_FUNCTION, "Failed to copy read memory to buffer.", error);
237
238 // FIXME: We should use the diagnostic system to report a warning if the
239 // `bytes_copied` is different from `size`.
240
241 return bytes_copied;
242}
243
244size_t ScriptedProcess::DoWriteMemory(lldb::addr_t vm_addr, const void *buf,
245 size_t size, Status &error) {
246 lldb::DataExtractorSP data_extractor_sp = std::make_shared<DataExtractor>(
247 buf, size, GetByteOrder(), GetAddressByteSize());
248
249 if (!data_extractor_sp || !data_extractor_sp->GetByteSize())
250 return 0;
251
252 lldb::offset_t bytes_written =
253 GetInterface().WriteMemoryAtAddress(vm_addr, data_extractor_sp, error);
254
255 if (!bytes_written || bytes_written == LLDB_INVALID_OFFSET)
256 return ScriptedInterface::ErrorWithMessage<size_t>(
257 LLVM_PRETTY_FUNCTION, "Failed to copy write buffer to memory.", error);
258
259 // FIXME: We should use the diagnostic system to report a warning if the
260 // `bytes_written` is different from `size`.
261
262 return bytes_written;
263}
264
266 assert(bp_site != nullptr);
267
268 if (bp_site->IsEnabled()) {
269 return {};
270 }
271
272 if (bp_site->HardwareRequired()) {
273 return Status("Scripted Processes don't support hardware breakpoints");
274 }
275
278
279 return error;
280}
281
283 return GetTarget().GetArchitecture();
284}
285
287 MemoryRegionInfo &region) {
289 if (auto region_or_err =
290 GetInterface().GetMemoryRegionContainingAddress(load_addr, error))
291 region = *region_or_err;
292
293 return error;
294}
295
298 lldb::addr_t address = 0;
299
300 while (auto region_or_err =
301 GetInterface().GetMemoryRegionContainingAddress(address, error)) {
302 if (error.Fail())
303 break;
304
305 MemoryRegionInfo &mem_region = *region_or_err;
306 auto range = mem_region.GetRange();
307 address += range.GetRangeBase() + range.GetByteSize();
308 region_list.push_back(mem_region);
309 }
310
311 return error;
312}
313
315
317 ThreadList &new_thread_list) {
318 // TODO: Implement
319 // This is supposed to get the current set of threads, if any of them are in
320 // old_thread_list then they get copied to new_thread_list, and then any
321 // actually new threads will get added to new_thread_list.
323
326
327 if (!thread_info_sp)
328 return ScriptedInterface::ErrorWithMessage<bool>(
329 LLVM_PRETTY_FUNCTION,
330 "Couldn't fetch thread list from Scripted Process.", error);
331
332 // Because `StructuredData::Dictionary` uses a `std::map<ConstString,
333 // ObjectSP>` for storage, each item is sorted based on the key alphabetical
334 // order. Since `GetThreadsInfo` provides thread indices as the key element,
335 // thread info comes ordered alphabetically, instead of numerically, so we
336 // need to sort the thread indices before creating thread.
337
338 StructuredData::ArraySP keys = thread_info_sp->GetKeys();
339
340 std::map<size_t, StructuredData::ObjectSP> sorted_threads;
341 auto sort_keys = [&sorted_threads,
342 &thread_info_sp](StructuredData::Object *item) -> bool {
343 if (!item)
344 return false;
345
346 llvm::StringRef key = item->GetStringValue();
347 size_t idx = 0;
348
349 // Make sure the provided index is actually an integer
350 if (!llvm::to_integer(key, idx))
351 return false;
352
353 sorted_threads[idx] = thread_info_sp->GetValueForKey(key);
354 return true;
355 };
356
357 size_t thread_count = thread_info_sp->GetSize();
358
359 if (!keys->ForEach(sort_keys) || sorted_threads.size() != thread_count)
360 // Might be worth showing the unsorted thread list instead of return early.
361 return ScriptedInterface::ErrorWithMessage<bool>(
362 LLVM_PRETTY_FUNCTION, "Couldn't sort thread list.", error);
363
364 auto create_scripted_thread =
365 [this, &error, &new_thread_list](
366 const std::pair<size_t, StructuredData::ObjectSP> pair) -> bool {
367 size_t idx = pair.first;
368 StructuredData::ObjectSP object_sp = pair.second;
369
370 if (!object_sp)
371 return ScriptedInterface::ErrorWithMessage<bool>(
372 LLVM_PRETTY_FUNCTION, "Invalid thread info object", error);
373
374 auto thread_or_error =
375 ScriptedThread::Create(*this, object_sp->GetAsGeneric());
376
377 if (!thread_or_error)
378 return ScriptedInterface::ErrorWithMessage<bool>(
379 LLVM_PRETTY_FUNCTION, toString(thread_or_error.takeError()), error);
380
381 ThreadSP thread_sp = thread_or_error.get();
382 lldbassert(thread_sp && "Couldn't initialize scripted thread.");
383
384 RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
385 if (!reg_ctx_sp)
386 return ScriptedInterface::ErrorWithMessage<bool>(
387 LLVM_PRETTY_FUNCTION,
388 llvm::Twine("Invalid Register Context for thread " + llvm::Twine(idx))
389 .str(),
390 error);
391
392 new_thread_list.AddThread(thread_sp);
393
394 return true;
395 };
396
397 llvm::for_each(sorted_threads, create_scripted_thread);
398
399 return new_thread_list.GetSize(false) > 0;
400}
401
403 // Let all threads recover from stopping and do any clean up based on the
404 // previous thread state (if any).
406}
407
409 info.Clear();
410 info.SetProcessID(GetID());
413 if (module_sp) {
414 const bool add_exe_file_as_first_arg = false;
415 info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
416 add_exe_file_as_first_arg);
417 }
418 return true;
419}
420
424 auto error_with_message = [&error](llvm::StringRef message) {
425 return ScriptedInterface::ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION,
426 message.data(), error);
427 };
428
430
431 if (!loaded_images_sp || !loaded_images_sp->GetSize())
432 return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>(
433 LLVM_PRETTY_FUNCTION, "No loaded images.", error);
434
435 ModuleList module_list;
436 Target &target = GetTarget();
437
438 auto reload_image = [&target, &module_list, &error_with_message](
439 StructuredData::Object *obj) -> bool {
441
442 if (!dict)
443 return error_with_message("Couldn't cast image object into dictionary.");
444
445 ModuleSpec module_spec;
446 llvm::StringRef value;
447
448 bool has_path = dict->HasKey("path");
449 bool has_uuid = dict->HasKey("uuid");
450 if (!has_path && !has_uuid)
451 return error_with_message("Dictionary should have key 'path' or 'uuid'");
452 if (!dict->HasKey("load_addr"))
453 return error_with_message("Dictionary is missing key 'load_addr'");
454
455 if (has_path) {
456 dict->GetValueForKeyAsString("path", value);
457 module_spec.GetFileSpec().SetPath(value);
458 }
459
460 if (has_uuid) {
461 dict->GetValueForKeyAsString("uuid", value);
462 module_spec.GetUUID().SetFromStringRef(value);
463 }
464 module_spec.GetArchitecture() = target.GetArchitecture();
465
466 ModuleSP module_sp =
467 target.GetOrCreateModule(module_spec, true /* notify */);
468
469 if (!module_sp)
470 return error_with_message("Couldn't create or get module.");
471
474 dict->GetValueForKeyAsInteger("load_addr", load_addr);
475 dict->GetValueForKeyAsInteger("slide", slide);
476 if (load_addr == LLDB_INVALID_ADDRESS)
477 return error_with_message(
478 "Couldn't get valid load address or slide offset.");
479
480 if (slide != LLDB_INVALID_OFFSET)
481 load_addr += slide;
482
483 bool changed = false;
484 module_sp->SetLoadAddress(target, load_addr, false /*=value_is_offset*/,
485 changed);
486
487 if (!changed && !module_sp->GetObjectFile())
488 return error_with_message("Couldn't set the load address for module.");
489
490 dict->GetValueForKeyAsString("path", value);
491 FileSpec objfile(value);
492 module_sp->SetFileSpecAndObjectName(objfile, objfile.GetFilename());
493
494 return module_list.AppendIfNeeded(module_sp);
495 };
496
497 if (!loaded_images_sp->ForEach(reload_image))
498 return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>(
499 LLVM_PRETTY_FUNCTION, "Couldn't reload all images.", error);
500
501 target.ModulesDidLoad(module_list);
502
503 return loaded_images_sp;
504}
505
508
510 if (!metadata_sp || !metadata_sp->GetSize())
511 return ScriptedInterface::ErrorWithMessage<StructuredData::DictionarySP>(
512 LLVM_PRETTY_FUNCTION, "No metadata.", error);
513
514 return metadata_sp;
515}
516
519 for (ThreadSP thread_sp : Threads()) {
520 if (const char *queue_name = thread_sp->GetQueueName()) {
521 QueueSP queue_sp = std::make_shared<Queue>(
522 m_process->shared_from_this(), thread_sp->GetQueueID(), queue_name);
523 m_queue_list.AddQueue(queue_sp);
524 }
525 }
526}
527
530 return *m_interface_up;
531}
532
534 StructuredData::GenericSP object_instance_sp =
536 if (object_instance_sp &&
537 object_instance_sp->GetType() == eStructuredDataTypeGeneric)
538 return object_instance_sp->GetAsGeneric()->GetValue();
539 return nullptr;
540}
static llvm::raw_ostream & error(Stream &strm)
#define lldbassert(x)
Definition: LLDBAssert.h:15
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
static constexpr lldb::ScriptLanguage g_supported_script_languages[]
An architecture specification class.
Definition: ArchSpec.h:31
Class that manages the actual breakpoint that will be inserted into the running program.
bool IsEnabled() const
Tells whether the current breakpoint site is enabled or not.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A file utility class.
Definition: FileSpec.h:56
const ConstString & GetFilename() const
Filename string const get accessor.
Definition: FileSpec.h:240
void SetPath(llvm::StringRef p)
Temporary helper for FileSystem change.
Definition: FileSpec.h:279
A collection class for Module objects.
Definition: ModuleList.h:103
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
Definition: ModuleList.cpp:280
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:53
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:89
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
void SetExecutableFile(const FileSpec &exe_file, bool add_exe_file_as_first_arg)
Definition: ProcessInfo.cpp:65
void SetArchitecture(const ArchSpec &arch)
Definition: ProcessInfo.h:65
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:69
A plug-in interface definition class for debugging a process.
Definition: Process.h:340
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:537
QueueList m_queue_list
The list of libdispatch queues at a given stop point.
Definition: Process.h:3038
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3399
ThreadList::ThreadIterable Threads()
Definition: Process.h:2211
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:3028
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3403
void SetPrivateState(lldb::StateType state)
Definition: Process.cpp:1419
virtual void Finalize(bool destructing)
This object is about to be destroyed, do any necessary cleanup.
Definition: Process.cpp:521
ThreadList m_thread_list
The threads for this process as the user will see them.
Definition: Process.h:3024
lldb::pid_t m_pid
Definition: Process.h:2994
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1276
void AddQueue(lldb::QueueSP queue)
Add a Queue to the QueueList.
Definition: QueueList.cpp:40
virtual lldb::ScriptedProcessInterfaceUP CreateScriptedProcessInterface()
StructuredData::GenericSP GetScriptObjectInstance()
llvm::StringRef GetClassName() const
StructuredData::DictionarySP GetArgsSP() const
virtual lldb::DataExtractorSP ReadMemoryAtAddress(lldb::addr_t address, size_t size, Status &error)
virtual StructuredData::DictionarySP GetThreadsInfo()
virtual Status Attach(const ProcessAttachInfo &attach_info)
virtual bool CreateBreakpoint(lldb::addr_t addr, Status &error)
virtual StructuredData::DictionarySP GetMetadata()
virtual StructuredData::ArraySP GetLoadedImages()
virtual lldb::offset_t WriteMemoryAtAddress(lldb::addr_t addr, lldb::DataExtractorSP data_sp, Status &error)
virtual llvm::Expected< StructuredData::GenericSP > CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx, StructuredData::DictionarySP args_sp, StructuredData::Generic *script_obj=nullptr)=0
Status DoResume() override
Resumes all of a process's threads as configured using the Thread run control functions.
Status DoAttachToProcessWithID(lldb::pid_t pid, const ProcessAttachInfo &attach_info) override
Attach to an existing process using a process ID.
bool CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name) override
Check if a plug-in instance can debug the file in module.
bool DoUpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list) override
Update the thread list following process plug-in's specific logic.
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size, Status &error) override
Actually do the reading of memory from a process.
lldb_private::StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override
const ScriptedMetadata m_scripted_metadata
void DidAttach(ArchSpec &process_arch) override
Called after attaching a process.
static llvm::StringRef GetPluginNameStatic()
Status GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) override
Obtain all the mapped memory regions within this process.
static bool IsScriptLanguageSupported(lldb::ScriptLanguage language)
bool IsAlive() override
Check if a process is still alive.
Status DoAttach(const ProcessAttachInfo &attach_info)
bool GetProcessInfo(ProcessInstanceInfo &info) override
void DidResume() override
Called after resuming a process.
Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override
Launch a new process.
size_t DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Status &error) override
Actually do the writing of memory to a process.
ScriptedProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const ScriptedMetadata &scripted_metadata, Status &error)
lldb::ScriptedProcessInterfaceUP m_interface_up
Status EnableBreakpointSite(BreakpointSite *bp_site) override
lldb_private::StructuredData::DictionarySP GetMetadata() override
Fetch process defined metadata.
Status DoAttachToProcessWithName(const char *process_name, const ProcessAttachInfo &attach_info) override
Attach to an existing process using a partial process name.
void RefreshStateAfterStop() override
Currently called as part of ShouldStop.
static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file_path, bool can_connect)
static llvm::StringRef GetPluginDescriptionStatic()
ScriptedProcessInterface & GetInterface() const
void DidLaunch() override
Called after launching a process.
Status DoGetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info) override
DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has removed non address bits from loa...
static llvm::Expected< std::shared_ptr< ScriptedThread > > Create(ScriptedProcess &process, StructuredData::Generic *script_object=nullptr)
An error handling class.
Definition: Status.h:44
virtual lldb::addr_t GetLoadAddress() const
Definition: StoppointSite.h:27
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
bool HasKey(llvm::StringRef key) const
std::shared_ptr< Generic > GenericSP
std::shared_ptr< Dictionary > DictionarySP
std::shared_ptr< Object > ObjectSP
std::shared_ptr< Array > ArraySP
const ProcessLaunchInfo & GetProcessLaunchInfo() const
Definition: Target.cpp:4788
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1695
lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify, Status *error_ptr=nullptr)
Find a binary on the system and return its Module, or return an existing Module that is already in th...
Definition: Target.cpp:2163
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1421
const ArchSpec & GetArchitecture() const
Definition: Target.h:1012
void AddThread(const lldb::ThreadSP &thread_sp)
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:83
void ClearThreadCache()
Clear the Thread* cache that each ThreadPlan contains.
bool SetFromStringRef(llvm::StringRef str)
Definition: UUID.cpp:97
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define LLDB_INVALID_OFFSET
Definition: lldb-defines.h:93
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
const char * toString(AppleArm64ExceptionClass EC)
Definition: SBAddress.h:15
ScriptLanguage
Script interpreter types.
std::shared_ptr< lldb_private::Queue > QueueSP
Definition: lldb-forward.h:390
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:438
uint64_t offset_t
Definition: lldb-types.h:83
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateRunning
Process or thread is running and can't be examined.
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
uint64_t pid_t
Definition: lldb-types.h:81
std::shared_ptr< lldb_private::Listener > ListenerSP
Definition: lldb-forward.h:360
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:436
@ eStructuredDataTypeGeneric
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:386
std::shared_ptr< lldb_private::DataExtractor > DataExtractorSP
Definition: lldb-forward.h:330
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365
BaseType GetRangeBase() const
Definition: RangeMap.h:45