1254721Semaste//===-- SBProcess.cpp -------------------------------------------*- C++ -*-===// 2254721Semaste// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6254721Semaste// 7254721Semaste//===----------------------------------------------------------------------===// 8254721Semaste 9254721Semaste#include "lldb/API/SBProcess.h" 10353358Sdim#include "SBReproducerPrivate.h" 11254721Semaste 12258054Semaste#include <inttypes.h> 13258054Semaste 14254721Semaste#include "lldb/lldb-defines.h" 15254721Semaste#include "lldb/lldb-types.h" 16254721Semaste 17254721Semaste#include "lldb/Core/Debugger.h" 18254721Semaste#include "lldb/Core/Module.h" 19296417Sdim#include "lldb/Core/PluginManager.h" 20254721Semaste#include "lldb/Core/StreamFile.h" 21309124Sdim#include "lldb/Target/MemoryRegionInfo.h" 22254721Semaste#include "lldb/Target/Process.h" 23254721Semaste#include "lldb/Target/RegisterContext.h" 24258054Semaste#include "lldb/Target/SystemRuntime.h" 25254721Semaste#include "lldb/Target/Target.h" 26254721Semaste#include "lldb/Target/Thread.h" 27341825Sdim#include "lldb/Utility/Args.h" 28353358Sdim#include "lldb/Utility/ProcessInfo.h" 29344779Sdim#include "lldb/Utility/State.h" 30321369Sdim#include "lldb/Utility/Stream.h" 31254721Semaste 32254721Semaste#include "lldb/API/SBBroadcaster.h" 33254721Semaste#include "lldb/API/SBCommandReturnObject.h" 34254721Semaste#include "lldb/API/SBDebugger.h" 35254721Semaste#include "lldb/API/SBEvent.h" 36360784Sdim#include "lldb/API/SBFile.h" 37254721Semaste#include "lldb/API/SBFileSpec.h" 38309124Sdim#include "lldb/API/SBMemoryRegionInfo.h" 39309124Sdim#include "lldb/API/SBMemoryRegionInfoList.h" 40314564Sdim#include "lldb/API/SBStream.h" 41314564Sdim#include "lldb/API/SBStringList.h" 42314564Sdim#include "lldb/API/SBStructuredData.h" 43254721Semaste#include "lldb/API/SBThread.h" 44280031Sdim#include "lldb/API/SBThreadCollection.h" 45321369Sdim#include "lldb/API/SBTrace.h" 46321369Sdim#include "lldb/API/SBTraceOptions.h" 47276479Sdim#include "lldb/API/SBUnixSignals.h" 48254721Semaste 49254721Semasteusing namespace lldb; 50254721Semasteusing namespace lldb_private; 51254721Semaste 52353358SdimSBProcess::SBProcess() : m_opaque_wp() { 53353358Sdim LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess); 54353358Sdim} 55254721Semaste 56254721Semaste// SBProcess constructor 57254721Semaste 58353358SdimSBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) { 59353358Sdim LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs); 60353358Sdim} 61254721Semaste 62314564SdimSBProcess::SBProcess(const lldb::ProcessSP &process_sp) 63353358Sdim : m_opaque_wp(process_sp) { 64353358Sdim LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp); 65353358Sdim} 66254721Semaste 67314564Sdimconst SBProcess &SBProcess::operator=(const SBProcess &rhs) { 68353358Sdim LLDB_RECORD_METHOD(const lldb::SBProcess &, 69353358Sdim SBProcess, operator=,(const lldb::SBProcess &), rhs); 70353358Sdim 71314564Sdim if (this != &rhs) 72314564Sdim m_opaque_wp = rhs.m_opaque_wp; 73353358Sdim return LLDB_RECORD_RESULT(*this); 74254721Semaste} 75254721Semaste 76254721Semaste// Destructor 77314564SdimSBProcess::~SBProcess() {} 78254721Semaste 79314564Sdimconst char *SBProcess::GetBroadcasterClassName() { 80353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, 81353358Sdim GetBroadcasterClassName); 82353358Sdim 83314564Sdim return Process::GetStaticBroadcasterClass().AsCString(); 84254721Semaste} 85254721Semaste 86314564Sdimconst char *SBProcess::GetPluginName() { 87353358Sdim LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName); 88353358Sdim 89314564Sdim ProcessSP process_sp(GetSP()); 90314564Sdim if (process_sp) { 91314564Sdim return process_sp->GetPluginName().GetCString(); 92314564Sdim } 93314564Sdim return "<Unknown>"; 94254721Semaste} 95254721Semaste 96314564Sdimconst char *SBProcess::GetShortPluginName() { 97353358Sdim LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName); 98353358Sdim 99314564Sdim ProcessSP process_sp(GetSP()); 100314564Sdim if (process_sp) { 101314564Sdim return process_sp->GetPluginName().GetCString(); 102314564Sdim } 103314564Sdim return "<Unknown>"; 104254721Semaste} 105254721Semaste 106314564Sdimlldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); } 107254721Semaste 108314564Sdimvoid SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } 109254721Semaste 110353358Sdimvoid SBProcess::Clear() { 111353358Sdim LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear); 112254721Semaste 113353358Sdim m_opaque_wp.reset(); 114353358Sdim} 115353358Sdim 116314564Sdimbool SBProcess::IsValid() const { 117353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid); 118353358Sdim return this->operator bool(); 119353358Sdim} 120353358SdimSBProcess::operator bool() const { 121353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool); 122353358Sdim 123314564Sdim ProcessSP process_sp(m_opaque_wp.lock()); 124314564Sdim return ((bool)process_sp && process_sp->IsValid()); 125254721Semaste} 126254721Semaste 127314564Sdimbool SBProcess::RemoteLaunch(char const **argv, char const **envp, 128314564Sdim const char *stdin_path, const char *stdout_path, 129314564Sdim const char *stderr_path, 130314564Sdim const char *working_directory, 131314564Sdim uint32_t launch_flags, bool stop_at_entry, 132314564Sdim lldb::SBError &error) { 133353358Sdim LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch, 134353358Sdim (const char **, const char **, const char *, const char *, 135353358Sdim const char *, const char *, uint32_t, bool, 136353358Sdim lldb::SBError &), 137353358Sdim argv, envp, stdin_path, stdout_path, stderr_path, 138353358Sdim working_directory, launch_flags, stop_at_entry, error); 139254721Semaste 140314564Sdim ProcessSP process_sp(GetSP()); 141314564Sdim if (process_sp) { 142314564Sdim std::lock_guard<std::recursive_mutex> guard( 143314564Sdim process_sp->GetTarget().GetAPIMutex()); 144314564Sdim if (process_sp->GetState() == eStateConnected) { 145314564Sdim if (stop_at_entry) 146314564Sdim launch_flags |= eLaunchFlagStopAtEntry; 147344779Sdim ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path), 148344779Sdim FileSpec(stderr_path), 149344779Sdim FileSpec(working_directory), launch_flags); 150314564Sdim Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 151314564Sdim if (exe_module) 152314564Sdim launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 153314564Sdim if (argv) 154314564Sdim launch_info.GetArguments().AppendArguments(argv); 155314564Sdim if (envp) 156341825Sdim launch_info.GetEnvironment() = Environment(envp); 157314564Sdim error.SetError(process_sp->Launch(launch_info)); 158314564Sdim } else { 159314564Sdim error.SetErrorString("must be in eStateConnected to call RemoteLaunch"); 160254721Semaste } 161314564Sdim } else { 162314564Sdim error.SetErrorString("unable to attach pid"); 163314564Sdim } 164276479Sdim 165314564Sdim return error.Success(); 166254721Semaste} 167254721Semaste 168314564Sdimbool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid, 169314564Sdim lldb::SBError &error) { 170353358Sdim LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, 171353358Sdim (lldb::pid_t, lldb::SBError &), pid, error); 172353358Sdim 173314564Sdim ProcessSP process_sp(GetSP()); 174314564Sdim if (process_sp) { 175314564Sdim std::lock_guard<std::recursive_mutex> guard( 176314564Sdim process_sp->GetTarget().GetAPIMutex()); 177314564Sdim if (process_sp->GetState() == eStateConnected) { 178314564Sdim ProcessAttachInfo attach_info; 179314564Sdim attach_info.SetProcessID(pid); 180314564Sdim error.SetError(process_sp->Attach(attach_info)); 181314564Sdim } else { 182314564Sdim error.SetErrorString( 183314564Sdim "must be in eStateConnected to call RemoteAttachToProcessWithID"); 184254721Semaste } 185314564Sdim } else { 186314564Sdim error.SetErrorString("unable to attach pid"); 187314564Sdim } 188254721Semaste 189314564Sdim return error.Success(); 190254721Semaste} 191254721Semaste 192314564Sdimuint32_t SBProcess::GetNumThreads() { 193353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); 194254721Semaste 195314564Sdim uint32_t num_threads = 0; 196314564Sdim ProcessSP process_sp(GetSP()); 197314564Sdim if (process_sp) { 198314564Sdim Process::StopLocker stop_locker; 199254721Semaste 200314564Sdim const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 201314564Sdim std::lock_guard<std::recursive_mutex> guard( 202314564Sdim process_sp->GetTarget().GetAPIMutex()); 203314564Sdim num_threads = process_sp->GetThreadList().GetSize(can_update); 204314564Sdim } 205276479Sdim 206314564Sdim return num_threads; 207254721Semaste} 208254721Semaste 209314564SdimSBThread SBProcess::GetSelectedThread() const { 210353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, 211353358Sdim GetSelectedThread); 212254721Semaste 213314564Sdim SBThread sb_thread; 214314564Sdim ThreadSP thread_sp; 215314564Sdim ProcessSP process_sp(GetSP()); 216314564Sdim if (process_sp) { 217314564Sdim std::lock_guard<std::recursive_mutex> guard( 218314564Sdim process_sp->GetTarget().GetAPIMutex()); 219314564Sdim thread_sp = process_sp->GetThreadList().GetSelectedThread(); 220314564Sdim sb_thread.SetThread(thread_sp); 221314564Sdim } 222254721Semaste 223353358Sdim return LLDB_RECORD_RESULT(sb_thread); 224254721Semaste} 225254721Semaste 226314564SdimSBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid, 227314564Sdim lldb::addr_t context) { 228353358Sdim LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, 229353358Sdim (lldb::tid_t, lldb::addr_t), tid, context); 230276479Sdim 231314564Sdim SBThread sb_thread; 232314564Sdim ThreadSP thread_sp; 233314564Sdim ProcessSP process_sp(GetSP()); 234314564Sdim if (process_sp) { 235314564Sdim std::lock_guard<std::recursive_mutex> guard( 236314564Sdim process_sp->GetTarget().GetAPIMutex()); 237314564Sdim thread_sp = process_sp->CreateOSPluginThread(tid, context); 238314564Sdim sb_thread.SetThread(thread_sp); 239314564Sdim } 240276479Sdim 241353358Sdim return LLDB_RECORD_RESULT(sb_thread); 242254721Semaste} 243254721Semaste 244314564SdimSBTarget SBProcess::GetTarget() const { 245353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); 246254721Semaste 247314564Sdim SBTarget sb_target; 248314564Sdim TargetSP target_sp; 249314564Sdim ProcessSP process_sp(GetSP()); 250314564Sdim if (process_sp) { 251314564Sdim target_sp = process_sp->GetTarget().shared_from_this(); 252314564Sdim sb_target.SetSP(target_sp); 253314564Sdim } 254276479Sdim 255353358Sdim return LLDB_RECORD_RESULT(sb_target); 256254721Semaste} 257254721Semaste 258314564Sdimsize_t SBProcess::PutSTDIN(const char *src, size_t src_len) { 259353358Sdim LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src, 260353358Sdim src_len); 261254721Semaste 262314564Sdim size_t ret_val = 0; 263314564Sdim ProcessSP process_sp(GetSP()); 264314564Sdim if (process_sp) { 265321369Sdim Status error; 266314564Sdim ret_val = process_sp->PutSTDIN(src, src_len, error); 267314564Sdim } 268254721Semaste 269314564Sdim return ret_val; 270254721Semaste} 271254721Semaste 272314564Sdimsize_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { 273353358Sdim LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst, 274353358Sdim dst_len); 275353358Sdim 276314564Sdim size_t bytes_read = 0; 277314564Sdim ProcessSP process_sp(GetSP()); 278314564Sdim if (process_sp) { 279321369Sdim Status error; 280314564Sdim bytes_read = process_sp->GetSTDOUT(dst, dst_len, error); 281314564Sdim } 282276479Sdim 283314564Sdim return bytes_read; 284254721Semaste} 285254721Semaste 286314564Sdimsize_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { 287353358Sdim LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst, 288353358Sdim dst_len); 289353358Sdim 290314564Sdim size_t bytes_read = 0; 291314564Sdim ProcessSP process_sp(GetSP()); 292314564Sdim if (process_sp) { 293321369Sdim Status error; 294314564Sdim bytes_read = process_sp->GetSTDERR(dst, dst_len, error); 295314564Sdim } 296254721Semaste 297314564Sdim return bytes_read; 298254721Semaste} 299254721Semaste 300314564Sdimsize_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { 301353358Sdim LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, 302353358Sdim (char *, size_t), dst, dst_len); 303353358Sdim 304314564Sdim size_t bytes_read = 0; 305314564Sdim ProcessSP process_sp(GetSP()); 306314564Sdim if (process_sp) { 307321369Sdim Status error; 308314564Sdim bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error); 309314564Sdim } 310276479Sdim 311314564Sdim return bytes_read; 312254721Semaste} 313254721Semaste 314321369Sdimlldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, 315321369Sdim lldb::SBError &error) { 316353358Sdim LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace, 317353358Sdim (lldb::SBTraceOptions &, lldb::SBError &), options, error); 318353358Sdim 319321369Sdim ProcessSP process_sp(GetSP()); 320321369Sdim error.Clear(); 321321369Sdim SBTrace trace_instance; 322321369Sdim trace_instance.SetSP(process_sp); 323321369Sdim lldb::user_id_t uid = LLDB_INVALID_UID; 324321369Sdim 325321369Sdim if (!process_sp) { 326321369Sdim error.SetErrorString("invalid process"); 327321369Sdim } else { 328321369Sdim uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref()); 329321369Sdim trace_instance.SetTraceUID(uid); 330321369Sdim } 331353358Sdim return LLDB_RECORD_RESULT(trace_instance); 332321369Sdim} 333321369Sdim 334360784Sdimvoid SBProcess::ReportEventState(const SBEvent &event, SBFile out) const { 335360784Sdim LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, 336360784Sdim (const SBEvent &, SBFile), event, out); 337360784Sdim 338360784Sdim return ReportEventState(event, out.m_opaque_sp); 339360784Sdim} 340360784Sdim 341314564Sdimvoid SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { 342353358Sdim LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, 343353358Sdim (const lldb::SBEvent &, FILE *), event, out); 344360784Sdim FileSP outfile = std::make_shared<NativeFile>(out, false); 345360784Sdim return ReportEventState(event, outfile); 346360784Sdim} 347353358Sdim 348360784Sdimvoid SBProcess::ReportEventState(const SBEvent &event, FileSP out) const { 349360784Sdim 350360784Sdim LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, 351360784Sdim (const SBEvent &, FileSP), event, out); 352360784Sdim 353360784Sdim if (!out || !out->IsValid()) 354314564Sdim return; 355254721Semaste 356314564Sdim ProcessSP process_sp(GetSP()); 357314564Sdim if (process_sp) { 358360784Sdim StreamFile stream(out); 359314564Sdim const StateType event_state = SBProcess::GetStateFromEvent(event); 360360784Sdim stream.Printf("Process %" PRIu64 " %s\n", 361314564Sdim process_sp->GetID(), SBDebugger::StateAsCString(event_state)); 362314564Sdim } 363254721Semaste} 364254721Semaste 365314564Sdimvoid SBProcess::AppendEventStateReport(const SBEvent &event, 366314564Sdim SBCommandReturnObject &result) { 367353358Sdim LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport, 368353358Sdim (const lldb::SBEvent &, lldb::SBCommandReturnObject &), 369353358Sdim event, result); 370353358Sdim 371314564Sdim ProcessSP process_sp(GetSP()); 372314564Sdim if (process_sp) { 373314564Sdim const StateType event_state = SBProcess::GetStateFromEvent(event); 374314564Sdim char message[1024]; 375314564Sdim ::snprintf(message, sizeof(message), "Process %" PRIu64 " %s\n", 376314564Sdim process_sp->GetID(), SBDebugger::StateAsCString(event_state)); 377254721Semaste 378314564Sdim result.AppendMessage(message); 379314564Sdim } 380254721Semaste} 381254721Semaste 382314564Sdimbool SBProcess::SetSelectedThread(const SBThread &thread) { 383353358Sdim LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread, 384353358Sdim (const lldb::SBThread &), thread); 385353358Sdim 386314564Sdim ProcessSP process_sp(GetSP()); 387314564Sdim if (process_sp) { 388314564Sdim std::lock_guard<std::recursive_mutex> guard( 389314564Sdim process_sp->GetTarget().GetAPIMutex()); 390314564Sdim return process_sp->GetThreadList().SetSelectedThreadByID( 391314564Sdim thread.GetThreadID()); 392314564Sdim } 393314564Sdim return false; 394254721Semaste} 395254721Semaste 396314564Sdimbool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { 397353358Sdim LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), 398353358Sdim tid); 399254721Semaste 400353358Sdim 401314564Sdim bool ret_val = false; 402314564Sdim ProcessSP process_sp(GetSP()); 403314564Sdim if (process_sp) { 404314564Sdim std::lock_guard<std::recursive_mutex> guard( 405314564Sdim process_sp->GetTarget().GetAPIMutex()); 406314564Sdim ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid); 407314564Sdim } 408254721Semaste 409314564Sdim return ret_val; 410254721Semaste} 411254721Semaste 412314564Sdimbool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { 413353358Sdim LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t), 414353358Sdim index_id); 415254721Semaste 416314564Sdim bool ret_val = false; 417314564Sdim ProcessSP process_sp(GetSP()); 418314564Sdim if (process_sp) { 419314564Sdim std::lock_guard<std::recursive_mutex> guard( 420314564Sdim process_sp->GetTarget().GetAPIMutex()); 421314564Sdim ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id); 422314564Sdim } 423254721Semaste 424254721Semaste 425314564Sdim return ret_val; 426254721Semaste} 427254721Semaste 428314564SdimSBThread SBProcess::GetThreadAtIndex(size_t index) { 429353358Sdim LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), 430353358Sdim index); 431254721Semaste 432314564Sdim SBThread sb_thread; 433314564Sdim ThreadSP thread_sp; 434314564Sdim ProcessSP process_sp(GetSP()); 435314564Sdim if (process_sp) { 436314564Sdim Process::StopLocker stop_locker; 437314564Sdim const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 438314564Sdim std::lock_guard<std::recursive_mutex> guard( 439314564Sdim process_sp->GetTarget().GetAPIMutex()); 440314564Sdim thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update); 441314564Sdim sb_thread.SetThread(thread_sp); 442314564Sdim } 443254721Semaste 444353358Sdim return LLDB_RECORD_RESULT(sb_thread); 445254721Semaste} 446254721Semaste 447314564Sdimuint32_t SBProcess::GetNumQueues() { 448353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); 449262528Semaste 450314564Sdim uint32_t num_queues = 0; 451314564Sdim ProcessSP process_sp(GetSP()); 452314564Sdim if (process_sp) { 453314564Sdim Process::StopLocker stop_locker; 454314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 455314564Sdim std::lock_guard<std::recursive_mutex> guard( 456314564Sdim process_sp->GetTarget().GetAPIMutex()); 457314564Sdim num_queues = process_sp->GetQueueList().GetSize(); 458262528Semaste } 459314564Sdim } 460262528Semaste 461314564Sdim return num_queues; 462262528Semaste} 463262528Semaste 464314564SdimSBQueue SBProcess::GetQueueAtIndex(size_t index) { 465353358Sdim LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), 466353358Sdim index); 467262528Semaste 468314564Sdim SBQueue sb_queue; 469314564Sdim QueueSP queue_sp; 470314564Sdim ProcessSP process_sp(GetSP()); 471314564Sdim if (process_sp) { 472314564Sdim Process::StopLocker stop_locker; 473314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 474314564Sdim std::lock_guard<std::recursive_mutex> guard( 475314564Sdim process_sp->GetTarget().GetAPIMutex()); 476314564Sdim queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index); 477314564Sdim sb_queue.SetQueue(queue_sp); 478262528Semaste } 479314564Sdim } 480262528Semaste 481353358Sdim return LLDB_RECORD_RESULT(sb_queue); 482262528Semaste} 483262528Semaste 484314564Sdimuint32_t SBProcess::GetStopID(bool include_expression_stops) { 485353358Sdim LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool), 486353358Sdim include_expression_stops); 487353358Sdim 488314564Sdim ProcessSP process_sp(GetSP()); 489314564Sdim if (process_sp) { 490314564Sdim std::lock_guard<std::recursive_mutex> guard( 491314564Sdim process_sp->GetTarget().GetAPIMutex()); 492314564Sdim if (include_expression_stops) 493314564Sdim return process_sp->GetStopID(); 494314564Sdim else 495314564Sdim return process_sp->GetLastNaturalStopID(); 496314564Sdim } 497314564Sdim return 0; 498254721Semaste} 499254721Semaste 500314564SdimSBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { 501353358Sdim LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, 502353358Sdim (uint32_t), stop_id); 503288943Sdim 504314564Sdim SBEvent sb_event; 505314564Sdim EventSP event_sp; 506314564Sdim ProcessSP process_sp(GetSP()); 507314564Sdim if (process_sp) { 508314564Sdim std::lock_guard<std::recursive_mutex> guard( 509314564Sdim process_sp->GetTarget().GetAPIMutex()); 510314564Sdim event_sp = process_sp->GetStopEventForStopID(stop_id); 511314564Sdim sb_event.reset(event_sp); 512314564Sdim } 513288943Sdim 514353358Sdim return LLDB_RECORD_RESULT(sb_event); 515288943Sdim} 516288943Sdim 517314564SdimStateType SBProcess::GetState() { 518353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState); 519254721Semaste 520314564Sdim StateType ret_val = eStateInvalid; 521314564Sdim ProcessSP process_sp(GetSP()); 522314564Sdim if (process_sp) { 523314564Sdim std::lock_guard<std::recursive_mutex> guard( 524314564Sdim process_sp->GetTarget().GetAPIMutex()); 525314564Sdim ret_val = process_sp->GetState(); 526314564Sdim } 527254721Semaste 528314564Sdim return ret_val; 529254721Semaste} 530254721Semaste 531314564Sdimint SBProcess::GetExitStatus() { 532353358Sdim LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); 533353358Sdim 534314564Sdim int exit_status = 0; 535314564Sdim ProcessSP process_sp(GetSP()); 536314564Sdim if (process_sp) { 537314564Sdim std::lock_guard<std::recursive_mutex> guard( 538314564Sdim process_sp->GetTarget().GetAPIMutex()); 539314564Sdim exit_status = process_sp->GetExitStatus(); 540314564Sdim } 541254721Semaste 542314564Sdim return exit_status; 543254721Semaste} 544254721Semaste 545314564Sdimconst char *SBProcess::GetExitDescription() { 546353358Sdim LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); 547353358Sdim 548353358Sdim const char *exit_desc = nullptr; 549314564Sdim ProcessSP process_sp(GetSP()); 550314564Sdim if (process_sp) { 551314564Sdim std::lock_guard<std::recursive_mutex> guard( 552314564Sdim process_sp->GetTarget().GetAPIMutex()); 553314564Sdim exit_desc = process_sp->GetExitDescription(); 554314564Sdim } 555314564Sdim return exit_desc; 556254721Semaste} 557254721Semaste 558314564Sdimlldb::pid_t SBProcess::GetProcessID() { 559353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID); 560353358Sdim 561314564Sdim lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID; 562314564Sdim ProcessSP process_sp(GetSP()); 563314564Sdim if (process_sp) 564314564Sdim ret_val = process_sp->GetID(); 565254721Semaste 566314564Sdim return ret_val; 567254721Semaste} 568254721Semaste 569314564Sdimuint32_t SBProcess::GetUniqueID() { 570353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID); 571353358Sdim 572314564Sdim uint32_t ret_val = 0; 573314564Sdim ProcessSP process_sp(GetSP()); 574314564Sdim if (process_sp) 575314564Sdim ret_val = process_sp->GetUniqueID(); 576314564Sdim return ret_val; 577254721Semaste} 578254721Semaste 579314564SdimByteOrder SBProcess::GetByteOrder() const { 580353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder); 581353358Sdim 582314564Sdim ByteOrder byteOrder = eByteOrderInvalid; 583314564Sdim ProcessSP process_sp(GetSP()); 584314564Sdim if (process_sp) 585314564Sdim byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder(); 586276479Sdim 587254721Semaste 588314564Sdim return byteOrder; 589254721Semaste} 590254721Semaste 591314564Sdimuint32_t SBProcess::GetAddressByteSize() const { 592353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize); 593353358Sdim 594314564Sdim uint32_t size = 0; 595314564Sdim ProcessSP process_sp(GetSP()); 596314564Sdim if (process_sp) 597314564Sdim size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize(); 598254721Semaste 599254721Semaste 600314564Sdim return size; 601254721Semaste} 602254721Semaste 603314564SdimSBError SBProcess::Continue() { 604353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); 605276479Sdim 606314564Sdim SBError sb_error; 607314564Sdim ProcessSP process_sp(GetSP()); 608254721Semaste 609314564Sdim if (process_sp) { 610314564Sdim std::lock_guard<std::recursive_mutex> guard( 611314564Sdim process_sp->GetTarget().GetAPIMutex()); 612276479Sdim 613314564Sdim if (process_sp->GetTarget().GetDebugger().GetAsyncExecution()) 614314564Sdim sb_error.ref() = process_sp->Resume(); 615254721Semaste else 616353358Sdim sb_error.ref() = process_sp->ResumeSynchronous(nullptr); 617314564Sdim } else 618314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 619254721Semaste 620353358Sdim return LLDB_RECORD_RESULT(sb_error); 621254721Semaste} 622254721Semaste 623314564SdimSBError SBProcess::Destroy() { 624353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy); 625353358Sdim 626314564Sdim SBError sb_error; 627314564Sdim ProcessSP process_sp(GetSP()); 628314564Sdim if (process_sp) { 629314564Sdim std::lock_guard<std::recursive_mutex> guard( 630314564Sdim process_sp->GetTarget().GetAPIMutex()); 631314564Sdim sb_error.SetError(process_sp->Destroy(false)); 632314564Sdim } else 633314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 634254721Semaste 635353358Sdim return LLDB_RECORD_RESULT(sb_error); 636254721Semaste} 637254721Semaste 638314564SdimSBError SBProcess::Stop() { 639353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop); 640353358Sdim 641314564Sdim SBError sb_error; 642314564Sdim ProcessSP process_sp(GetSP()); 643314564Sdim if (process_sp) { 644314564Sdim std::lock_guard<std::recursive_mutex> guard( 645314564Sdim process_sp->GetTarget().GetAPIMutex()); 646314564Sdim sb_error.SetError(process_sp->Halt()); 647314564Sdim } else 648314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 649254721Semaste 650353358Sdim return LLDB_RECORD_RESULT(sb_error); 651254721Semaste} 652254721Semaste 653314564SdimSBError SBProcess::Kill() { 654353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill); 655353358Sdim 656314564Sdim SBError sb_error; 657314564Sdim ProcessSP process_sp(GetSP()); 658314564Sdim if (process_sp) { 659314564Sdim std::lock_guard<std::recursive_mutex> guard( 660314564Sdim process_sp->GetTarget().GetAPIMutex()); 661314564Sdim sb_error.SetError(process_sp->Destroy(true)); 662314564Sdim } else 663314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 664254721Semaste 665353358Sdim return LLDB_RECORD_RESULT(sb_error); 666254721Semaste} 667254721Semaste 668314564SdimSBError SBProcess::Detach() { 669353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach); 670353358Sdim 671314564Sdim // FIXME: This should come from a process default. 672314564Sdim bool keep_stopped = false; 673353358Sdim return LLDB_RECORD_RESULT(Detach(keep_stopped)); 674254721Semaste} 675254721Semaste 676314564SdimSBError SBProcess::Detach(bool keep_stopped) { 677353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped); 678353358Sdim 679314564Sdim SBError sb_error; 680314564Sdim ProcessSP process_sp(GetSP()); 681314564Sdim if (process_sp) { 682314564Sdim std::lock_guard<std::recursive_mutex> guard( 683314564Sdim process_sp->GetTarget().GetAPIMutex()); 684314564Sdim sb_error.SetError(process_sp->Detach(keep_stopped)); 685314564Sdim } else 686314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 687254721Semaste 688353358Sdim return LLDB_RECORD_RESULT(sb_error); 689254721Semaste} 690254721Semaste 691314564SdimSBError SBProcess::Signal(int signo) { 692353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo); 693353358Sdim 694314564Sdim SBError sb_error; 695314564Sdim ProcessSP process_sp(GetSP()); 696314564Sdim if (process_sp) { 697314564Sdim std::lock_guard<std::recursive_mutex> guard( 698314564Sdim process_sp->GetTarget().GetAPIMutex()); 699314564Sdim sb_error.SetError(process_sp->Signal(signo)); 700314564Sdim } else 701314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 702353358Sdim 703353358Sdim return LLDB_RECORD_RESULT(sb_error); 704254721Semaste} 705254721Semaste 706314564SdimSBUnixSignals SBProcess::GetUnixSignals() { 707353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals); 708353358Sdim 709314564Sdim if (auto process_sp = GetSP()) 710353358Sdim return LLDB_RECORD_RESULT(SBUnixSignals{process_sp}); 711276479Sdim 712353358Sdim return LLDB_RECORD_RESULT(SBUnixSignals{}); 713276479Sdim} 714276479Sdim 715314564Sdimvoid SBProcess::SendAsyncInterrupt() { 716353358Sdim LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt); 717353358Sdim 718314564Sdim ProcessSP process_sp(GetSP()); 719314564Sdim if (process_sp) { 720314564Sdim process_sp->SendAsyncInterrupt(); 721314564Sdim } 722254721Semaste} 723254721Semaste 724314564SdimSBThread SBProcess::GetThreadByID(tid_t tid) { 725353358Sdim LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t), 726353358Sdim tid); 727353358Sdim 728314564Sdim SBThread sb_thread; 729314564Sdim ThreadSP thread_sp; 730314564Sdim ProcessSP process_sp(GetSP()); 731314564Sdim if (process_sp) { 732314564Sdim Process::StopLocker stop_locker; 733314564Sdim const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 734314564Sdim std::lock_guard<std::recursive_mutex> guard( 735314564Sdim process_sp->GetTarget().GetAPIMutex()); 736314564Sdim thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update); 737314564Sdim sb_thread.SetThread(thread_sp); 738314564Sdim } 739254721Semaste 740353358Sdim return LLDB_RECORD_RESULT(sb_thread); 741254721Semaste} 742254721Semaste 743314564SdimSBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { 744353358Sdim LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t), 745353358Sdim index_id); 746353358Sdim 747314564Sdim SBThread sb_thread; 748314564Sdim ThreadSP thread_sp; 749314564Sdim ProcessSP process_sp(GetSP()); 750314564Sdim if (process_sp) { 751314564Sdim Process::StopLocker stop_locker; 752314564Sdim const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 753314564Sdim std::lock_guard<std::recursive_mutex> guard( 754314564Sdim process_sp->GetTarget().GetAPIMutex()); 755314564Sdim thread_sp = 756314564Sdim process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update); 757314564Sdim sb_thread.SetThread(thread_sp); 758314564Sdim } 759254721Semaste 760353358Sdim return LLDB_RECORD_RESULT(sb_thread); 761254721Semaste} 762254721Semaste 763314564SdimStateType SBProcess::GetStateFromEvent(const SBEvent &event) { 764353358Sdim LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, 765353358Sdim (const lldb::SBEvent &), event); 766254721Semaste 767314564Sdim StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get()); 768276479Sdim 769314564Sdim return ret_val; 770254721Semaste} 771254721Semaste 772314564Sdimbool SBProcess::GetRestartedFromEvent(const SBEvent &event) { 773353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, 774353358Sdim (const lldb::SBEvent &), event); 775296417Sdim 776314564Sdim bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get()); 777296417Sdim 778314564Sdim return ret_val; 779254721Semaste} 780254721Semaste 781314564Sdimsize_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) { 782353358Sdim LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent, 783353358Sdim (const lldb::SBEvent &), event); 784353358Sdim 785314564Sdim return Process::ProcessEventData::GetNumRestartedReasons(event.get()); 786254721Semaste} 787254721Semaste 788254721Semasteconst char * 789314564SdimSBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event, 790314564Sdim size_t idx) { 791353358Sdim LLDB_RECORD_STATIC_METHOD(const char *, SBProcess, 792353358Sdim GetRestartedReasonAtIndexFromEvent, 793353358Sdim (const lldb::SBEvent &, size_t), event, idx); 794353358Sdim 795314564Sdim return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx); 796254721Semaste} 797254721Semaste 798314564SdimSBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) { 799353358Sdim LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, 800353358Sdim (const lldb::SBEvent &), event); 801353358Sdim 802314564Sdim ProcessSP process_sp = 803314564Sdim Process::ProcessEventData::GetProcessFromEvent(event.get()); 804314564Sdim if (!process_sp) { 805341825Sdim // StructuredData events also know the process they come from. Try that. 806314564Sdim process_sp = EventDataStructuredData::GetProcessFromEvent(event.get()); 807314564Sdim } 808314564Sdim 809353358Sdim return LLDB_RECORD_RESULT(SBProcess(process_sp)); 810254721Semaste} 811254721Semaste 812314564Sdimbool SBProcess::GetInterruptedFromEvent(const SBEvent &event) { 813353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, 814353358Sdim (const lldb::SBEvent &), event); 815353358Sdim 816314564Sdim return Process::ProcessEventData::GetInterruptedFromEvent(event.get()); 817288943Sdim} 818288943Sdim 819314564Sdimlldb::SBStructuredData 820314564SdimSBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) { 821353358Sdim LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess, 822353358Sdim GetStructuredDataFromEvent, (const lldb::SBEvent &), 823353358Sdim event); 824353358Sdim 825353358Sdim return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP())); 826254721Semaste} 827254721Semaste 828314564Sdimbool SBProcess::EventIsProcessEvent(const SBEvent &event) { 829353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, 830353358Sdim (const lldb::SBEvent &), event); 831353358Sdim 832314564Sdim return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) && 833314564Sdim !EventIsStructuredDataEvent(event); 834314564Sdim} 835254721Semaste 836314564Sdimbool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) { 837353358Sdim LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, 838353358Sdim (const lldb::SBEvent &), event); 839353358Sdim 840314564Sdim EventSP event_sp = event.GetSP(); 841314564Sdim EventData *event_data = event_sp ? event_sp->GetData() : nullptr; 842314564Sdim return event_data && (event_data->GetFlavor() == 843314564Sdim EventDataStructuredData::GetFlavorString()); 844314564Sdim} 845254721Semaste 846314564SdimSBBroadcaster SBProcess::GetBroadcaster() const { 847353358Sdim LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, 848353358Sdim GetBroadcaster); 849254721Semaste 850353358Sdim 851314564Sdim ProcessSP process_sp(GetSP()); 852254721Semaste 853314564Sdim SBBroadcaster broadcaster(process_sp.get(), false); 854314564Sdim 855314564Sdim 856353358Sdim return LLDB_RECORD_RESULT(broadcaster); 857254721Semaste} 858254721Semaste 859314564Sdimconst char *SBProcess::GetBroadcasterClass() { 860353358Sdim LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, 861353358Sdim GetBroadcasterClass); 862353358Sdim 863314564Sdim return Process::GetStaticBroadcasterClass().AsCString(); 864254721Semaste} 865254721Semaste 866314564Sdimsize_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len, 867314564Sdim SBError &sb_error) { 868353358Sdim LLDB_RECORD_DUMMY(size_t, SBProcess, ReadMemory, 869353358Sdim (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst, 870353358Sdim dst_len, sb_error); 871254721Semaste 872314564Sdim size_t bytes_read = 0; 873254721Semaste 874314564Sdim ProcessSP process_sp(GetSP()); 875254721Semaste 876276479Sdim 877314564Sdim if (process_sp) { 878314564Sdim Process::StopLocker stop_locker; 879314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 880314564Sdim std::lock_guard<std::recursive_mutex> guard( 881314564Sdim process_sp->GetTarget().GetAPIMutex()); 882314564Sdim bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref()); 883314564Sdim } else { 884314564Sdim sb_error.SetErrorString("process is running"); 885254721Semaste } 886314564Sdim } else { 887314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 888314564Sdim } 889254721Semaste 890314564Sdim return bytes_read; 891254721Semaste} 892254721Semaste 893314564Sdimsize_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, 894314564Sdim lldb::SBError &sb_error) { 895353358Sdim LLDB_RECORD_DUMMY(size_t, SBProcess, ReadCStringFromMemory, 896353358Sdim (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf, 897353358Sdim size, sb_error); 898353358Sdim 899314564Sdim size_t bytes_read = 0; 900314564Sdim ProcessSP process_sp(GetSP()); 901314564Sdim if (process_sp) { 902314564Sdim Process::StopLocker stop_locker; 903314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 904314564Sdim std::lock_guard<std::recursive_mutex> guard( 905314564Sdim process_sp->GetTarget().GetAPIMutex()); 906314564Sdim bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size, 907314564Sdim sb_error.ref()); 908314564Sdim } else { 909314564Sdim sb_error.SetErrorString("process is running"); 910254721Semaste } 911314564Sdim } else { 912314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 913314564Sdim } 914314564Sdim return bytes_read; 915254721Semaste} 916254721Semaste 917314564Sdimuint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, 918314564Sdim lldb::SBError &sb_error) { 919353358Sdim LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, 920353358Sdim (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size, 921353358Sdim sb_error); 922353358Sdim 923314564Sdim uint64_t value = 0; 924314564Sdim ProcessSP process_sp(GetSP()); 925314564Sdim if (process_sp) { 926314564Sdim Process::StopLocker stop_locker; 927314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 928314564Sdim std::lock_guard<std::recursive_mutex> guard( 929314564Sdim process_sp->GetTarget().GetAPIMutex()); 930314564Sdim value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0, 931314564Sdim sb_error.ref()); 932314564Sdim } else { 933314564Sdim sb_error.SetErrorString("process is running"); 934254721Semaste } 935314564Sdim } else { 936314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 937314564Sdim } 938314564Sdim return value; 939254721Semaste} 940254721Semaste 941314564Sdimlldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr, 942314564Sdim lldb::SBError &sb_error) { 943353358Sdim LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, 944353358Sdim (lldb::addr_t, lldb::SBError &), addr, sb_error); 945353358Sdim 946314564Sdim lldb::addr_t ptr = LLDB_INVALID_ADDRESS; 947314564Sdim ProcessSP process_sp(GetSP()); 948314564Sdim if (process_sp) { 949314564Sdim Process::StopLocker stop_locker; 950314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 951314564Sdim std::lock_guard<std::recursive_mutex> guard( 952314564Sdim process_sp->GetTarget().GetAPIMutex()); 953314564Sdim ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref()); 954314564Sdim } else { 955314564Sdim sb_error.SetErrorString("process is running"); 956254721Semaste } 957314564Sdim } else { 958314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 959314564Sdim } 960314564Sdim return ptr; 961254721Semaste} 962254721Semaste 963314564Sdimsize_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, 964314564Sdim SBError &sb_error) { 965353358Sdim LLDB_RECORD_DUMMY(size_t, SBProcess, WriteMemory, 966353358Sdim (lldb::addr_t, const void *, size_t, lldb::SBError &), addr, 967353358Sdim src, src_len, sb_error); 968353358Sdim 969314564Sdim size_t bytes_written = 0; 970254721Semaste 971314564Sdim ProcessSP process_sp(GetSP()); 972254721Semaste 973314564Sdim if (process_sp) { 974314564Sdim Process::StopLocker stop_locker; 975314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 976314564Sdim std::lock_guard<std::recursive_mutex> guard( 977314564Sdim process_sp->GetTarget().GetAPIMutex()); 978314564Sdim bytes_written = 979314564Sdim process_sp->WriteMemory(addr, src, src_len, sb_error.ref()); 980314564Sdim } else { 981314564Sdim sb_error.SetErrorString("process is running"); 982254721Semaste } 983314564Sdim } 984254721Semaste 985314564Sdim return bytes_written; 986254721Semaste} 987254721Semaste 988314564Sdimbool SBProcess::GetDescription(SBStream &description) { 989353358Sdim LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), 990353358Sdim description); 991353358Sdim 992314564Sdim Stream &strm = description.ref(); 993254721Semaste 994314564Sdim ProcessSP process_sp(GetSP()); 995314564Sdim if (process_sp) { 996314564Sdim char path[PATH_MAX]; 997314564Sdim GetTarget().GetExecutable().GetPath(path, sizeof(path)); 998314564Sdim Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 999353358Sdim const char *exe_name = nullptr; 1000314564Sdim if (exe_module) 1001314564Sdim exe_name = exe_module->GetFileSpec().GetFilename().AsCString(); 1002254721Semaste 1003314564Sdim strm.Printf("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s", 1004314564Sdim process_sp->GetID(), lldb_private::StateAsCString(GetState()), 1005314564Sdim GetNumThreads(), exe_name ? ", executable = " : "", 1006314564Sdim exe_name ? exe_name : ""); 1007314564Sdim } else 1008314564Sdim strm.PutCString("No value"); 1009254721Semaste 1010314564Sdim return true; 1011254721Semaste} 1012254721Semaste 1013254721Semasteuint32_t 1014314564SdimSBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { 1015353358Sdim LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess, 1016353358Sdim GetNumSupportedHardwareWatchpoints, 1017353358Sdim (lldb::SBError &), sb_error); 1018254721Semaste 1019314564Sdim uint32_t num = 0; 1020314564Sdim ProcessSP process_sp(GetSP()); 1021314564Sdim if (process_sp) { 1022314564Sdim std::lock_guard<std::recursive_mutex> guard( 1023314564Sdim process_sp->GetTarget().GetAPIMutex()); 1024314564Sdim sb_error.SetError(process_sp->GetWatchpointSupportInfo(num)); 1025314564Sdim } else { 1026314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 1027314564Sdim } 1028314564Sdim return num; 1029254721Semaste} 1030254721Semaste 1031314564Sdimuint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec, 1032314564Sdim lldb::SBError &sb_error) { 1033353358Sdim LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage, 1034353358Sdim (lldb::SBFileSpec &, lldb::SBError &), 1035353358Sdim sb_remote_image_spec, sb_error); 1036353358Sdim 1037314564Sdim return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error); 1038296417Sdim} 1039296417Sdim 1040314564Sdimuint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec, 1041314564Sdim const lldb::SBFileSpec &sb_remote_image_spec, 1042314564Sdim lldb::SBError &sb_error) { 1043353358Sdim LLDB_RECORD_METHOD( 1044353358Sdim uint32_t, SBProcess, LoadImage, 1045353358Sdim (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &), 1046353358Sdim sb_local_image_spec, sb_remote_image_spec, sb_error); 1047353358Sdim 1048314564Sdim ProcessSP process_sp(GetSP()); 1049314564Sdim if (process_sp) { 1050314564Sdim Process::StopLocker stop_locker; 1051314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1052314564Sdim std::lock_guard<std::recursive_mutex> guard( 1053321369Sdim process_sp->GetTarget().GetAPIMutex()); 1054314564Sdim PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1055314564Sdim return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec, 1056314564Sdim *sb_remote_image_spec, sb_error.ref()); 1057314564Sdim } else { 1058314564Sdim sb_error.SetErrorString("process is running"); 1059254721Semaste } 1060353358Sdim } else { 1061321369Sdim sb_error.SetErrorString("process is invalid"); 1062314564Sdim } 1063314564Sdim return LLDB_INVALID_IMAGE_TOKEN; 1064254721Semaste} 1065276479Sdim 1066341825Sdimuint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, 1067341825Sdim SBStringList &paths, 1068353358Sdim lldb::SBFileSpec &loaded_path, 1069341825Sdim lldb::SBError &error) { 1070353358Sdim LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, 1071353358Sdim (const lldb::SBFileSpec &, lldb::SBStringList &, 1072353358Sdim lldb::SBFileSpec &, lldb::SBError &), 1073353358Sdim image_spec, paths, loaded_path, error); 1074353358Sdim 1075341825Sdim ProcessSP process_sp(GetSP()); 1076341825Sdim if (process_sp) { 1077341825Sdim Process::StopLocker stop_locker; 1078341825Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1079341825Sdim std::lock_guard<std::recursive_mutex> guard( 1080341825Sdim process_sp->GetTarget().GetAPIMutex()); 1081341825Sdim PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1082341825Sdim size_t num_paths = paths.GetSize(); 1083341825Sdim std::vector<std::string> paths_vec; 1084341825Sdim paths_vec.reserve(num_paths); 1085341825Sdim for (size_t i = 0; i < num_paths; i++) 1086341825Sdim paths_vec.push_back(paths.GetStringAtIndex(i)); 1087341825Sdim FileSpec loaded_spec; 1088353358Sdim 1089353358Sdim uint32_t token = platform_sp->LoadImageUsingPaths( 1090353358Sdim process_sp.get(), *image_spec, paths_vec, error.ref(), &loaded_spec); 1091353358Sdim if (token != LLDB_INVALID_IMAGE_TOKEN) 1092353358Sdim loaded_path = loaded_spec; 1093353358Sdim return token; 1094341825Sdim } else { 1095341825Sdim error.SetErrorString("process is running"); 1096341825Sdim } 1097353358Sdim } else { 1098341825Sdim error.SetErrorString("process is invalid"); 1099341825Sdim } 1100353358Sdim 1101341825Sdim return LLDB_INVALID_IMAGE_TOKEN; 1102341825Sdim} 1103341825Sdim 1104314564Sdimlldb::SBError SBProcess::UnloadImage(uint32_t image_token) { 1105353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t), 1106353358Sdim image_token); 1107353358Sdim 1108314564Sdim lldb::SBError sb_error; 1109314564Sdim ProcessSP process_sp(GetSP()); 1110314564Sdim if (process_sp) { 1111314564Sdim Process::StopLocker stop_locker; 1112314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1113314564Sdim std::lock_guard<std::recursive_mutex> guard( 1114314564Sdim process_sp->GetTarget().GetAPIMutex()); 1115314564Sdim PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1116314564Sdim sb_error.SetError( 1117314564Sdim platform_sp->UnloadImage(process_sp.get(), image_token)); 1118314564Sdim } else { 1119314564Sdim sb_error.SetErrorString("process is running"); 1120254721Semaste } 1121314564Sdim } else 1122314564Sdim sb_error.SetErrorString("invalid process"); 1123353358Sdim return LLDB_RECORD_RESULT(sb_error); 1124254721Semaste} 1125258054Semaste 1126314564Sdimlldb::SBError SBProcess::SendEventData(const char *event_data) { 1127353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *), 1128353358Sdim event_data); 1129353358Sdim 1130314564Sdim lldb::SBError sb_error; 1131314564Sdim ProcessSP process_sp(GetSP()); 1132314564Sdim if (process_sp) { 1133314564Sdim Process::StopLocker stop_locker; 1134314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1135314564Sdim std::lock_guard<std::recursive_mutex> guard( 1136314564Sdim process_sp->GetTarget().GetAPIMutex()); 1137314564Sdim sb_error.SetError(process_sp->SendEventData(event_data)); 1138314564Sdim } else { 1139314564Sdim sb_error.SetErrorString("process is running"); 1140276479Sdim } 1141314564Sdim } else 1142314564Sdim sb_error.SetErrorString("invalid process"); 1143353358Sdim return LLDB_RECORD_RESULT(sb_error); 1144276479Sdim} 1145276479Sdim 1146314564Sdimuint32_t SBProcess::GetNumExtendedBacktraceTypes() { 1147353358Sdim LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes); 1148353358Sdim 1149314564Sdim ProcessSP process_sp(GetSP()); 1150314564Sdim if (process_sp && process_sp->GetSystemRuntime()) { 1151314564Sdim SystemRuntime *runtime = process_sp->GetSystemRuntime(); 1152314564Sdim return runtime->GetExtendedBacktraceTypes().size(); 1153314564Sdim } 1154314564Sdim return 0; 1155258054Semaste} 1156258054Semaste 1157314564Sdimconst char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { 1158353358Sdim LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex, 1159353358Sdim (uint32_t), idx); 1160353358Sdim 1161314564Sdim ProcessSP process_sp(GetSP()); 1162314564Sdim if (process_sp && process_sp->GetSystemRuntime()) { 1163314564Sdim SystemRuntime *runtime = process_sp->GetSystemRuntime(); 1164314564Sdim const std::vector<ConstString> &names = 1165314564Sdim runtime->GetExtendedBacktraceTypes(); 1166314564Sdim if (idx < names.size()) { 1167314564Sdim return names[idx].AsCString(); 1168258054Semaste } 1169314564Sdim } 1170353358Sdim return nullptr; 1171258054Semaste} 1172280031Sdim 1173314564SdimSBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) { 1174353358Sdim LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, 1175353358Sdim (lldb::addr_t), addr); 1176353358Sdim 1177314564Sdim ProcessSP process_sp(GetSP()); 1178314564Sdim SBThreadCollection threads; 1179314564Sdim if (process_sp) { 1180314564Sdim threads = SBThreadCollection(process_sp->GetHistoryThreads(addr)); 1181314564Sdim } 1182353358Sdim return LLDB_RECORD_RESULT(threads); 1183280031Sdim} 1184280031Sdim 1185314564Sdimbool SBProcess::IsInstrumentationRuntimePresent( 1186314564Sdim InstrumentationRuntimeType type) { 1187353358Sdim LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, 1188353358Sdim (lldb::InstrumentationRuntimeType), type); 1189353358Sdim 1190314564Sdim ProcessSP process_sp(GetSP()); 1191314564Sdim if (!process_sp) 1192314564Sdim return false; 1193314564Sdim 1194360784Sdim std::lock_guard<std::recursive_mutex> guard( 1195360784Sdim process_sp->GetTarget().GetAPIMutex()); 1196360784Sdim 1197314564Sdim InstrumentationRuntimeSP runtime_sp = 1198314564Sdim process_sp->GetInstrumentationRuntime(type); 1199314564Sdim 1200314564Sdim if (!runtime_sp.get()) 1201314564Sdim return false; 1202314564Sdim 1203314564Sdim return runtime_sp->IsActive(); 1204280031Sdim} 1205296417Sdim 1206314564Sdimlldb::SBError SBProcess::SaveCore(const char *file_name) { 1207353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *), 1208353358Sdim file_name); 1209353358Sdim 1210314564Sdim lldb::SBError error; 1211314564Sdim ProcessSP process_sp(GetSP()); 1212314564Sdim if (!process_sp) { 1213314564Sdim error.SetErrorString("SBProcess is invalid"); 1214353358Sdim return LLDB_RECORD_RESULT(error); 1215314564Sdim } 1216296417Sdim 1217314564Sdim std::lock_guard<std::recursive_mutex> guard( 1218314564Sdim process_sp->GetTarget().GetAPIMutex()); 1219296417Sdim 1220314564Sdim if (process_sp->GetState() != eStateStopped) { 1221314564Sdim error.SetErrorString("the process is not stopped"); 1222353358Sdim return LLDB_RECORD_RESULT(error); 1223314564Sdim } 1224296417Sdim 1225344779Sdim FileSpec core_file(file_name); 1226314564Sdim error.ref() = PluginManager::SaveCore(process_sp, core_file); 1227353358Sdim return LLDB_RECORD_RESULT(error); 1228296417Sdim} 1229309124Sdim 1230309124Sdimlldb::SBError 1231314564SdimSBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr, 1232314564Sdim SBMemoryRegionInfo &sb_region_info) { 1233353358Sdim LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, 1234353358Sdim (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr, 1235353358Sdim sb_region_info); 1236353358Sdim 1237314564Sdim lldb::SBError sb_error; 1238314564Sdim ProcessSP process_sp(GetSP()); 1239314564Sdim if (process_sp) { 1240314564Sdim Process::StopLocker stop_locker; 1241314564Sdim if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1242314564Sdim std::lock_guard<std::recursive_mutex> guard( 1243314564Sdim process_sp->GetTarget().GetAPIMutex()); 1244344779Sdim 1245314564Sdim sb_error.ref() = 1246344779Sdim process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref()); 1247314564Sdim } else { 1248314564Sdim sb_error.SetErrorString("process is running"); 1249309124Sdim } 1250314564Sdim } else { 1251314564Sdim sb_error.SetErrorString("SBProcess is invalid"); 1252314564Sdim } 1253353358Sdim return LLDB_RECORD_RESULT(sb_error); 1254309124Sdim} 1255309124Sdim 1256314564Sdimlldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { 1257353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess, 1258353358Sdim GetMemoryRegions); 1259353358Sdim 1260314564Sdim lldb::SBMemoryRegionInfoList sb_region_list; 1261344779Sdim 1262314564Sdim ProcessSP process_sp(GetSP()); 1263344779Sdim Process::StopLocker stop_locker; 1264344779Sdim if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) { 1265344779Sdim std::lock_guard<std::recursive_mutex> guard( 1266344779Sdim process_sp->GetTarget().GetAPIMutex()); 1267344779Sdim 1268344779Sdim process_sp->GetMemoryRegions(sb_region_list.ref()); 1269314564Sdim } 1270344779Sdim 1271353358Sdim return LLDB_RECORD_RESULT(sb_region_list); 1272309124Sdim} 1273327952Sdim 1274327952Sdimlldb::SBProcessInfo SBProcess::GetProcessInfo() { 1275353358Sdim LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo); 1276353358Sdim 1277327952Sdim lldb::SBProcessInfo sb_proc_info; 1278327952Sdim ProcessSP process_sp(GetSP()); 1279327952Sdim ProcessInstanceInfo proc_info; 1280327952Sdim if (process_sp && process_sp->GetProcessInfo(proc_info)) { 1281327952Sdim sb_proc_info.SetProcessInfo(proc_info); 1282327952Sdim } 1283353358Sdim return LLDB_RECORD_RESULT(sb_proc_info); 1284327952Sdim} 1285353358Sdim 1286353358Sdimnamespace lldb_private { 1287353358Sdimnamespace repro { 1288353358Sdim 1289353358Sdimtemplate <> 1290353358Sdimvoid RegisterMethods<SBProcess>(Registry &R) { 1291353358Sdim LLDB_REGISTER_CONSTRUCTOR(SBProcess, ()); 1292353358Sdim LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &)); 1293353358Sdim LLDB_REGISTER_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &)); 1294353358Sdim LLDB_REGISTER_METHOD(const lldb::SBProcess &, 1295353358Sdim SBProcess, operator=,(const lldb::SBProcess &)); 1296353358Sdim LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, 1297353358Sdim GetBroadcasterClassName, ()); 1298353358Sdim LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ()); 1299353358Sdim LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ()); 1300353358Sdim LLDB_REGISTER_METHOD(void, SBProcess, Clear, ()); 1301353358Sdim LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ()); 1302353358Sdim LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ()); 1303353358Sdim LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch, 1304353358Sdim (const char **, const char **, const char *, 1305353358Sdim const char *, const char *, const char *, uint32_t, 1306353358Sdim bool, lldb::SBError &)); 1307353358Sdim LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, 1308353358Sdim (lldb::pid_t, lldb::SBError &)); 1309353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ()); 1310353358Sdim LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread, 1311353358Sdim ()); 1312353358Sdim LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, 1313353358Sdim (lldb::tid_t, lldb::addr_t)); 1314353358Sdim LLDB_REGISTER_METHOD_CONST(lldb::SBTarget, SBProcess, GetTarget, ()); 1315353358Sdim LLDB_REGISTER_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t)); 1316353358Sdim LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t)); 1317353358Sdim LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t)); 1318353358Sdim LLDB_REGISTER_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, 1319353358Sdim (char *, size_t)); 1320353358Sdim LLDB_REGISTER_METHOD(lldb::SBTrace, SBProcess, StartTrace, 1321353358Sdim (lldb::SBTraceOptions &, lldb::SBError &)); 1322353358Sdim LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState, 1323353358Sdim (const lldb::SBEvent &, FILE *)); 1324360784Sdim LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState, 1325360784Sdim (const lldb::SBEvent &, FileSP)); 1326360784Sdim LLDB_REGISTER_METHOD_CONST(void, SBProcess, ReportEventState, 1327360784Sdim (const lldb::SBEvent &, SBFile)); 1328353358Sdim LLDB_REGISTER_METHOD( 1329353358Sdim void, SBProcess, AppendEventStateReport, 1330353358Sdim (const lldb::SBEvent &, lldb::SBCommandReturnObject &)); 1331353358Sdim LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThread, 1332353358Sdim (const lldb::SBThread &)); 1333353358Sdim LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t)); 1334353358Sdim LLDB_REGISTER_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, 1335353358Sdim (uint32_t)); 1336353358Sdim LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t)); 1337353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumQueues, ()); 1338353358Sdim LLDB_REGISTER_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t)); 1339353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetStopID, (bool)); 1340353358Sdim LLDB_REGISTER_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, 1341353358Sdim (uint32_t)); 1342353358Sdim LLDB_REGISTER_METHOD(lldb::StateType, SBProcess, GetState, ()); 1343353358Sdim LLDB_REGISTER_METHOD(int, SBProcess, GetExitStatus, ()); 1344353358Sdim LLDB_REGISTER_METHOD(const char *, SBProcess, GetExitDescription, ()); 1345353358Sdim LLDB_REGISTER_METHOD(lldb::pid_t, SBProcess, GetProcessID, ()); 1346353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetUniqueID, ()); 1347353358Sdim LLDB_REGISTER_METHOD_CONST(lldb::ByteOrder, SBProcess, GetByteOrder, ()); 1348353358Sdim LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, GetAddressByteSize, ()); 1349353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Continue, ()); 1350353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Destroy, ()); 1351353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Stop, ()); 1352353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Kill, ()); 1353353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, ()); 1354353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Detach, (bool)); 1355353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, Signal, (int)); 1356353358Sdim LLDB_REGISTER_METHOD(lldb::SBUnixSignals, SBProcess, GetUnixSignals, ()); 1357353358Sdim LLDB_REGISTER_METHOD(void, SBProcess, SendAsyncInterrupt, ()); 1358353358Sdim LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByID, 1359353358Sdim (lldb::tid_t)); 1360353358Sdim LLDB_REGISTER_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, 1361353358Sdim (uint32_t)); 1362353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, 1363353358Sdim (const lldb::SBEvent &)); 1364353358Sdim LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, 1365353358Sdim (const lldb::SBEvent &)); 1366353358Sdim LLDB_REGISTER_STATIC_METHOD(size_t, SBProcess, 1367353358Sdim GetNumRestartedReasonsFromEvent, 1368353358Sdim (const lldb::SBEvent &)); 1369353358Sdim LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, 1370353358Sdim GetRestartedReasonAtIndexFromEvent, 1371353358Sdim (const lldb::SBEvent &, size_t)); 1372353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, 1373353358Sdim (const lldb::SBEvent &)); 1374353358Sdim LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, 1375353358Sdim (const lldb::SBEvent &)); 1376353358Sdim LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBProcess, 1377353358Sdim GetStructuredDataFromEvent, 1378353358Sdim (const lldb::SBEvent &)); 1379353358Sdim LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, 1380353358Sdim (const lldb::SBEvent &)); 1381353358Sdim LLDB_REGISTER_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, 1382353358Sdim (const lldb::SBEvent &)); 1383353358Sdim LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster, 1384353358Sdim ()); 1385353358Sdim LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass, 1386353358Sdim ()); 1387353358Sdim LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, 1388353358Sdim (lldb::addr_t, uint32_t, lldb::SBError &)); 1389353358Sdim LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, 1390353358Sdim (lldb::addr_t, lldb::SBError &)); 1391353358Sdim LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &)); 1392353358Sdim LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess, 1393353358Sdim GetNumSupportedHardwareWatchpoints, 1394353358Sdim (lldb::SBError &)); 1395353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage, 1396353358Sdim (lldb::SBFileSpec &, lldb::SBError &)); 1397353358Sdim LLDB_REGISTER_METHOD( 1398353358Sdim uint32_t, SBProcess, LoadImage, 1399353358Sdim (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &)); 1400353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, 1401353358Sdim (const lldb::SBFileSpec &, lldb::SBStringList &, 1402353358Sdim lldb::SBFileSpec &, lldb::SBError &)); 1403353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t)); 1404353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SendEventData, 1405353358Sdim (const char *)); 1406353358Sdim LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumExtendedBacktraceTypes, ()); 1407353358Sdim LLDB_REGISTER_METHOD(const char *, SBProcess, 1408353358Sdim GetExtendedBacktraceTypeAtIndex, (uint32_t)); 1409353358Sdim LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, 1410353358Sdim (lldb::addr_t)); 1411353358Sdim LLDB_REGISTER_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, 1412353358Sdim (lldb::InstrumentationRuntimeType)); 1413353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *)); 1414353358Sdim LLDB_REGISTER_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, 1415353358Sdim (lldb::addr_t, lldb::SBMemoryRegionInfo &)); 1416353358Sdim LLDB_REGISTER_METHOD(lldb::SBMemoryRegionInfoList, SBProcess, 1417353358Sdim GetMemoryRegions, ()); 1418353358Sdim LLDB_REGISTER_METHOD(lldb::SBProcessInfo, SBProcess, GetProcessInfo, ()); 1419353358Sdim} 1420353358Sdim 1421353358Sdim} 1422353358Sdim} 1423