83 return Process::GetStaticBroadcasterClass().AsCString();
89 ProcessSP process_sp(
GetSP());
91 return process_sp->GetPluginName().GetCString();
99 ProcessSP process_sp(
GetSP());
101 return process_sp->GetPluginName().GetCString();
118 return this->
operator bool();
120 SBProcess::operator bool()
const {
124 return ((
bool)process_sp && process_sp->IsValid());
128 const char *stdin_path,
const char *stdout_path,
129 const char *stderr_path,
130 const char *working_directory,
131 uint32_t launch_flags,
bool stop_at_entry,
134 (
const char **,
const char **,
const char *,
const char *,
135 const char *,
const char *,
uint32_t,
bool,
137 argv, envp, stdin_path, stdout_path, stderr_path,
138 working_directory, launch_flags, stop_at_entry, error);
140 ProcessSP process_sp(
GetSP());
142 std::lock_guard<std::recursive_mutex> guard(
143 process_sp->GetTarget().GetAPIMutex());
146 launch_flags |= eLaunchFlagStopAtEntry;
149 FileSpec(working_directory), launch_flags);
150 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
157 error.
SetError(process_sp->Launch(launch_info));
159 error.
SetErrorString(
"must be in eStateConnected to call RemoteLaunch");
173 ProcessSP process_sp(
GetSP());
175 std::lock_guard<std::recursive_mutex> guard(
176 process_sp->GetTarget().GetAPIMutex());
180 error.
SetError(process_sp->Attach(attach_info));
183 "must be in eStateConnected to call RemoteAttachToProcessWithID");
196 ProcessSP process_sp(
GetSP());
200 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
201 std::lock_guard<std::recursive_mutex> guard(
202 process_sp->GetTarget().GetAPIMutex());
203 num_threads = process_sp->GetThreadList().GetSize(can_update);
215 ProcessSP process_sp(
GetSP());
217 std::lock_guard<std::recursive_mutex> guard(
218 process_sp->GetTarget().GetAPIMutex());
219 thread_sp = process_sp->GetThreadList().GetSelectedThread();
220 sb_thread.SetThread(thread_sp);
233 ProcessSP process_sp(
GetSP());
235 std::lock_guard<std::recursive_mutex> guard(
236 process_sp->GetTarget().GetAPIMutex());
237 thread_sp = process_sp->CreateOSPluginThread(tid, context);
238 sb_thread.SetThread(thread_sp);
249 ProcessSP process_sp(
GetSP());
251 target_sp = process_sp->GetTarget().shared_from_this();
252 sb_target.
SetSP(target_sp);
263 ProcessSP process_sp(
GetSP());
266 ret_val = process_sp->PutSTDIN(src, src_len, error);
276 size_t bytes_read = 0;
277 ProcessSP process_sp(
GetSP());
280 bytes_read = process_sp->GetSTDOUT(dst, dst_len, error);
290 size_t bytes_read = 0;
291 ProcessSP process_sp(
GetSP());
294 bytes_read = process_sp->GetSTDERR(dst, dst_len, error);
302 (
char *,
size_t), dst, dst_len);
304 size_t bytes_read = 0;
305 ProcessSP process_sp(
GetSP());
308 bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error);
319 ProcessSP process_sp(
GetSP());
322 trace_instance.
SetSP(process_sp);
341 ProcessSP process_sp(
GetSP());
345 int message_len = ::snprintf(
346 message,
sizeof(message),
"Process %" PRIu64
" %s\n",
350 ::fwrite(message, 1, message_len, out);
360 ProcessSP process_sp(
GetSP());
364 ::snprintf(message,
sizeof(message),
"Process %" PRIu64
" %s\n",
375 ProcessSP process_sp(
GetSP());
377 std::lock_guard<std::recursive_mutex> guard(
378 process_sp->GetTarget().GetAPIMutex());
379 return process_sp->GetThreadList().SetSelectedThreadByID(
390 bool ret_val =
false;
391 ProcessSP process_sp(
GetSP());
393 std::lock_guard<std::recursive_mutex> guard(
394 process_sp->GetTarget().GetAPIMutex());
395 ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid);
405 bool ret_val =
false;
406 ProcessSP process_sp(
GetSP());
408 std::lock_guard<std::recursive_mutex> guard(
409 process_sp->GetTarget().GetAPIMutex());
410 ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id);
423 ProcessSP process_sp(
GetSP());
426 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
427 std::lock_guard<std::recursive_mutex> guard(
428 process_sp->GetTarget().GetAPIMutex());
429 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
430 sb_thread.SetThread(thread_sp);
440 ProcessSP process_sp(
GetSP());
443 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
444 std::lock_guard<std::recursive_mutex> guard(
445 process_sp->GetTarget().GetAPIMutex());
446 num_queues = process_sp->GetQueueList().GetSize();
459 ProcessSP process_sp(
GetSP());
462 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
463 std::lock_guard<std::recursive_mutex> guard(
464 process_sp->GetTarget().GetAPIMutex());
465 queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
475 include_expression_stops);
477 ProcessSP process_sp(
GetSP());
479 std::lock_guard<std::recursive_mutex> guard(
480 process_sp->GetTarget().GetAPIMutex());
481 if (include_expression_stops)
482 return process_sp->GetStopID();
484 return process_sp->GetLastNaturalStopID();
495 ProcessSP process_sp(
GetSP());
497 std::lock_guard<std::recursive_mutex> guard(
498 process_sp->GetTarget().GetAPIMutex());
499 event_sp = process_sp->GetStopEventForStopID(stop_id);
500 sb_event.
reset(event_sp);
510 ProcessSP process_sp(
GetSP());
512 std::lock_guard<std::recursive_mutex> guard(
513 process_sp->GetTarget().GetAPIMutex());
514 ret_val = process_sp->GetState();
524 ProcessSP process_sp(
GetSP());
526 std::lock_guard<std::recursive_mutex> guard(
527 process_sp->GetTarget().GetAPIMutex());
528 exit_status = process_sp->GetExitStatus();
537 const char *exit_desc = NULL;
538 ProcessSP process_sp(
GetSP());
540 std::lock_guard<std::recursive_mutex> guard(
541 process_sp->GetTarget().GetAPIMutex());
542 exit_desc = process_sp->GetExitDescription();
551 ProcessSP process_sp(
GetSP());
553 ret_val = process_sp->GetID();
562 ProcessSP process_sp(
GetSP());
564 ret_val = process_sp->GetUniqueID();
572 ProcessSP process_sp(
GetSP());
574 byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
584 ProcessSP process_sp(
GetSP());
586 size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
596 ProcessSP process_sp(
GetSP());
599 std::lock_guard<std::recursive_mutex> guard(
600 process_sp->GetTarget().GetAPIMutex());
602 if (process_sp->GetTarget().GetDebugger().GetAsyncExecution())
603 sb_error.
ref() = process_sp->Resume();
605 sb_error.
ref() = process_sp->ResumeSynchronous(NULL);
616 ProcessSP process_sp(
GetSP());
618 std::lock_guard<std::recursive_mutex> guard(
619 process_sp->GetTarget().GetAPIMutex());
620 sb_error.
SetError(process_sp->Destroy(
false));
631 ProcessSP process_sp(
GetSP());
633 std::lock_guard<std::recursive_mutex> guard(
634 process_sp->GetTarget().GetAPIMutex());
635 sb_error.
SetError(process_sp->Halt());
646 ProcessSP process_sp(
GetSP());
648 std::lock_guard<std::recursive_mutex> guard(
649 process_sp->GetTarget().GetAPIMutex());
650 sb_error.
SetError(process_sp->Destroy(
true));
661 bool keep_stopped =
false;
669 ProcessSP process_sp(
GetSP());
671 std::lock_guard<std::recursive_mutex> guard(
672 process_sp->GetTarget().GetAPIMutex());
673 sb_error.
SetError(process_sp->Detach(keep_stopped));
684 ProcessSP process_sp(
GetSP());
686 std::lock_guard<std::recursive_mutex> guard(
687 process_sp->GetTarget().GetAPIMutex());
688 sb_error.
SetError(process_sp->Signal(signo));
698 if (
auto process_sp =
GetSP())
707 ProcessSP process_sp(
GetSP());
709 process_sp->SendAsyncInterrupt();
719 ProcessSP process_sp(
GetSP());
722 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
723 std::lock_guard<std::recursive_mutex> guard(
724 process_sp->GetTarget().GetAPIMutex());
725 thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update);
726 sb_thread.SetThread(thread_sp);
738 ProcessSP process_sp(
GetSP());
741 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
742 std::lock_guard<std::recursive_mutex> guard(
743 process_sp->GetTarget().GetAPIMutex());
745 process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update);
746 sb_thread.SetThread(thread_sp);
756 StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.
get());
765 bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.
get());
774 return Process::ProcessEventData::GetNumRestartedReasons(event.
get());
784 return Process::ProcessEventData::GetRestartedReasonAtIndex(event.
get(), idx);
791 ProcessSP process_sp =
792 Process::ProcessEventData::GetProcessFromEvent(event.
get());
795 process_sp = EventDataStructuredData::GetProcessFromEvent(event.
get());
805 return Process::ProcessEventData::GetInterruptedFromEvent(event.
get());
829 EventSP event_sp =
event.GetSP();
830 EventData *event_data = event_sp ? event_sp->GetData() :
nullptr;
831 return event_data && (event_data->
GetFlavor() ==
832 EventDataStructuredData::GetFlavorString());
840 ProcessSP process_sp(
GetSP());
852 return Process::GetStaticBroadcasterClass().AsCString();
861 size_t bytes_read = 0;
863 ProcessSP process_sp(
GetSP());
868 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
869 std::lock_guard<std::recursive_mutex> guard(
870 process_sp->GetTarget().GetAPIMutex());
871 bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.
ref());
888 size_t bytes_read = 0;
889 ProcessSP process_sp(
GetSP());
892 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
893 std::lock_guard<std::recursive_mutex> guard(
894 process_sp->GetTarget().GetAPIMutex());
895 bytes_read = process_sp->ReadCStringFromMemory(addr, (
char *)buf, size,
913 ProcessSP process_sp(
GetSP());
916 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
917 std::lock_guard<std::recursive_mutex> guard(
918 process_sp->GetTarget().GetAPIMutex());
919 value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
936 ProcessSP process_sp(
GetSP());
939 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
940 std::lock_guard<std::recursive_mutex> guard(
941 process_sp->GetTarget().GetAPIMutex());
942 ptr = process_sp->ReadPointerFromMemory(addr, sb_error.
ref());
956 src, src_len, sb_error);
958 size_t bytes_written = 0;
960 ProcessSP process_sp(
GetSP());
964 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
965 std::lock_guard<std::recursive_mutex> guard(
966 process_sp->GetTarget().GetAPIMutex());
968 process_sp->WriteMemory(addr, src, src_len, sb_error.
ref());
974 return bytes_written;
983 ProcessSP process_sp(
GetSP());
987 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
988 const char *exe_name = NULL;
992 strm.
Printf(
"SBProcess: pid = %" PRIu64
", state = %s, threads = %d%s%s",
995 exe_name ? exe_name :
"");
1009 ProcessSP process_sp(
GetSP());
1011 std::lock_guard<std::recursive_mutex> guard(
1012 process_sp->GetTarget().GetAPIMutex());
1013 sb_error.
SetError(process_sp->GetWatchpointSupportInfo(num));
1024 sb_remote_image_spec, sb_error);
1035 sb_local_image_spec, sb_remote_image_spec, sb_error);
1037 ProcessSP process_sp(
GetSP());
1040 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1041 std::lock_guard<std::recursive_mutex> guard(
1042 process_sp->GetTarget().GetAPIMutex());
1043 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1044 return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec,
1045 *sb_remote_image_spec, sb_error.
ref());
1062 image_spec, paths, loaded_path, error);
1064 ProcessSP process_sp(
GetSP());
1067 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1068 std::lock_guard<std::recursive_mutex> guard(
1069 process_sp->GetTarget().GetAPIMutex());
1070 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1071 size_t num_paths = paths.
GetSize();
1072 std::vector<std::string> paths_vec;
1073 paths_vec.reserve(num_paths);
1074 for (
size_t i = 0; i < num_paths; i++)
1078 uint32_t token = platform_sp->LoadImageUsingPaths(
1079 process_sp.get(), *image_spec, paths_vec, error.
ref(), &loaded_spec);
1081 loaded_path = loaded_spec;
1098 ProcessSP process_sp(
GetSP());
1101 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1102 std::lock_guard<std::recursive_mutex> guard(
1103 process_sp->GetTarget().GetAPIMutex());
1104 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1106 platform_sp->UnloadImage(process_sp.get(), image_token));
1120 ProcessSP process_sp(
GetSP());
1123 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1124 std::lock_guard<std::recursive_mutex> guard(
1125 process_sp->GetTarget().GetAPIMutex());
1126 sb_error.
SetError(process_sp->SendEventData(event_data));
1138 ProcessSP process_sp(
GetSP());
1139 if (process_sp && process_sp->GetSystemRuntime()) {
1150 ProcessSP process_sp(
GetSP());
1151 if (process_sp && process_sp->GetSystemRuntime()) {
1153 const std::vector<ConstString> &names =
1155 if (idx < names.size()) {
1156 return names[idx].AsCString();
1166 ProcessSP process_sp(
GetSP());
1179 ProcessSP process_sp(
GetSP());
1183 InstrumentationRuntimeSP runtime_sp =
1184 process_sp->GetInstrumentationRuntime(type);
1186 if (!runtime_sp.get())
1189 return runtime_sp->IsActive();
1197 ProcessSP process_sp(
GetSP());
1203 std::lock_guard<std::recursive_mutex> guard(
1204 process_sp->GetTarget().GetAPIMutex());
1212 error.
ref() = PluginManager::SaveCore(process_sp, core_file);
1224 ProcessSP process_sp(
GetSP());
1227 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1228 std::lock_guard<std::recursive_mutex> guard(
1229 process_sp->GetTarget().GetAPIMutex());
1232 process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref());
1248 ProcessSP process_sp(
GetSP());
1250 if (process_sp && stop_locker.
TryLock(&process_sp->GetRunLock())) {
1251 std::lock_guard<std::recursive_mutex> guard(
1252 process_sp->GetTarget().GetAPIMutex());
1254 process_sp->GetMemoryRegions(sb_region_list.ref());
1264 ProcessSP process_sp(
GetSP());
1266 if (process_sp && process_sp->GetProcessInfo(proc_info)) {
1267 sb_proc_info.SetProcessInfo(proc_info);
1290 (
const char **,
const char **,
const char *,
1291 const char *,
const char *,
const char *,
uint32_t,
void RegisterMethods< SBProcess >(Registry &R)
ConstString & GetFilename()
Filename string get accessor.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
static const char * GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event, size_t idx)
The registry contains a unique mapping between functions and their ID.
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Enumerations for broadcasting.
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
static const char * StateAsCString(lldb::StateType state)
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
void SetExecutableFile(const FileSpec &exe_file, bool add_exe_file_as_first_arg)
A stream class that can stream formatted output to a file.
size_t ReadCStringFromMemory(addr_t addr, void *buf, size_t size, lldb::SBError &error)
void ReportEventState(const lldb::SBEvent &event, FILE *out) const
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
size_t GetSTDOUT(char *dst, size_t dst_len) const
void SetSP(const lldb::ProcessSP &process_sp)
static bool GetRestartedFromEvent(const lldb::SBEvent &event)
#define LLDB_INVALID_PROCESS_ID
void SetSP(const ProcessSP &process_sp)
#define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature,...)
bool TryLock(ProcessRunLock *lock)
#define LLDB_RECORD_DUMMY(Result, Class, Method, Signature,...)
The LLDB_RECORD_DUMMY macro is special because it doesn't actually record anything.
lldb::addr_t ReadPointerFromMemory(addr_t addr, lldb::SBError &error)
#define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)
void SetProcessID(lldb::pid_t pid)
lldb::SBError UnloadImage(uint32_t image_token)
const char * GetBroadcasterClass() const
static lldb::StateType GetStateFromEvent(const lldb::SBEvent &event)
void SetError(uint32_t err, lldb::ErrorType type)
lldb::ByteOrder GetByteOrder() const
lldb::SBQueue GetQueueAtIndex(size_t index)
lldb::EventSP & GetSP() const
lldb::pid_t GetProcessID()
Gets the process ID.
Process or thread is stopped and can be examined.
lldb::SBThread CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context)
bool SetSelectedThreadByIndexID(uint32_t index_id)
size_t GetSTDERR(char *dst, size_t dst_len) const
lldb_private::Event * get() const
void SendAsyncInterrupt()
const char * GetPluginName()
#define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)
lldb::SBThreadCollection GetHistoryThreads(addr_t addr)
uint32_t GetNumSupportedHardwareWatchpoints(lldb::SBError &error) const
uint32_t LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, SBStringList &paths, lldb::SBFileSpec &loaded_path, lldb::SBError &error)
Load a shared library into this process, starting with a library name and a list of paths...
void SetErrorString(const char *err_str)
lldb::SBMemoryRegionInfoList GetMemoryRegions()
Return the list of memory regions within the process.
class LLDB_API SBFileSpec
void SetSP(const lldb::TargetSP &target_sp)
void SetQueue(const lldb::QueueSP &queue_sp)
lldb::SBEvent GetStopEventForStopID(uint32_t stop_id)
Gets the stop event corresponding to stop ID.
lldb::SBUnixSignals GetUnixSignals()
lldb::SBError SendEventData(const char *data)
lldb::TraceOptionsSP m_traceoptions_sp
bool GetDescription(lldb::SBStream &description)
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
lldb::SBBroadcaster GetBroadcaster() const
class LLDB_API SBStructuredData
const char * GetShortPluginName()
lldb::ProcessWP m_opaque_wp
lldb_private::Status & ref()
uint32_t GetNumExtendedBacktraceTypes()
Return the number of different thread-origin extended backtraces this process can support...
static lldb::SBProcess GetProcessFromEvent(const lldb::SBEvent &event)
InstrumentationRuntimeType
lldb::tid_t GetThreadID() const
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
size_t PutSTDIN(const char *src, size_t src_len)
A class that describes an executable image and its associated object and symbol files.
Process is connected to remote debug services, but not launched or attached to anything yet...
bool RemoteLaunch(char const **argv, char const **envp, const char *stdin_path, const char *stdout_path, const char *stderr_path, const char *working_directory, uint32_t launch_flags, bool stop_at_entry, lldb::SBError &error)
size_t ReadMemory(addr_t addr, void *buf, size_t size, lldb::SBError &error)
void reset(lldb::EventSP &event_sp)
void AppendEventStateReport(const lldb::SBEvent &event, lldb::SBCommandReturnObject &result)
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
lldb::ProcessSP GetSP() const
lldb::SBTrace StartTrace(SBTraceOptions &options, lldb::SBError &error)
Start Tracing with the given SBTraceOptions.
lldb::SBProcessInfo GetProcessInfo()
Return information about the process.
Environment & GetEnvironment()
uint32_t GetUniqueID()
Gets the unique ID associated with this process object.
class LLDB_API SBThreadCollection
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
uint32_t LoadImage(lldb::SBFileSpec &remote_image_spec, lldb::SBError &error)
Load a shared library into this process.
lldb::SBError SaveCore(const char *file_name)
Save the state of the process in a core file (or mini dump on Windows).
static bool EventIsProcessEvent(const lldb::SBEvent &event)
const char * GetExtendedBacktraceTypeAtIndex(uint32_t idx)
Return the name of one of the thread-origin extended backtrace methods.
static lldb::SBStructuredData GetStructuredDataFromEvent(const lldb::SBEvent &event)
lldb_private::Stream & ref()
void SetTraceUID(lldb::user_id_t uid)
bool SetSelectedThreadByID(lldb::tid_t tid)
lldb::SBFileSpec GetExecutable()
#define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature,...)
#define LLDB_INVALID_IMAGE_TOKEN
void AppendMessage(const char *message)
uint32_t GetAddressByteSize() const
static const char * GetBroadcasterClass()
const char * GetStringAtIndex(size_t idx)
lldb::SBThread GetThreadByIndexID(uint32_t index_id)
uint64_t ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, lldb::SBError &error)
const FileSpec & GetPlatformFileSpec() const
Get accessor for the module platform file specification.
uint32_t GetPath(char *dst_path, size_t dst_len) const
virtual const std::vector< ConstString > & GetExtendedBacktraceTypes()
Return a list of thread origin extended backtraces that may be available.
bool RemoteAttachToProcessWithID(lldb::pid_t pid, lldb::SBError &error)
Remote connection related functions.
uint32_t GetStopID(bool include_expression_stops=false)
lldb::SBThread GetThreadByID(lldb::tid_t sb_thread_id)
static size_t GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event)
const lldb::SBProcess & operator=(const lldb::SBProcess &rhs)
lldb::SBThread GetSelectedThread() const
lldb::SBError Signal(int signal)
const char * GetExitDescription()
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
static const char * GetBroadcasterClassName()
size_t WriteMemory(addr_t addr, const void *buf, size_t size, lldb::SBError &error)
bool SetSelectedThread(const lldb::SBThread &thread)
static bool EventIsStructuredDataEvent(const lldb::SBEvent &event)
static bool GetInterruptedFromEvent(const lldb::SBEvent &event)
lldb::SBTarget GetTarget() const
lldb::SBThread GetThreadAtIndex(size_t index)
void AppendArguments(const Args &rhs)
size_t GetAsyncProfileData(char *dst, size_t dst_len) const
bool IsInstrumentationRuntimePresent(InstrumentationRuntimeType type)
virtual ConstString GetFlavor() const =0
#define LLDB_RECORD_RESULT(Result)
lldb::StateType GetState()
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
A plug-in interface definition class for system runtimes.
lldb::SBError GetMemoryRegionInfo(lldb::addr_t load_addr, lldb::SBMemoryRegionInfo ®ion_info)
Query the address load_addr and store the details of the memory region that contains it in the suppli...