lldb/source/API/SBProcess.cpp

   1 //===-- SBProcess.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 "lldb/API/SBProcess.h"
  10 #include "lldb/Utility/Instrumentation.h"
  11
  12 #include <cinttypes>
  13
  14 #include "lldb/lldb-defines.h"
  15 #include "lldb/lldb-types.h"
  16
  17 #include "lldb/Core/Debugger.h"
  18 #include "lldb/Core/Module.h"
  19 #include "lldb/Core/PluginManager.h"
  20 #include "lldb/Core/StructuredDataImpl.h"
  21 #include "lldb/Host/StreamFile.h"
  22 #include "lldb/Target/MemoryRegionInfo.h"
  23 #include "lldb/Target/Process.h"
  24 #include "lldb/Target/RegisterContext.h"
  25 #include "lldb/Target/SystemRuntime.h"
  26 #include "lldb/Target/Target.h"
  27 #include "lldb/Target/Thread.h"
  28 #include "lldb/Utility/Args.h"
  29 #include "lldb/Utility/ProcessInfo.h"
  30 #include "lldb/Utility/State.h"
  31 #include "lldb/Utility/Stream.h"
  32
  33 #include "lldb/API/SBBroadcaster.h"
  34 #include "lldb/API/SBCommandReturnObject.h"
  35 #include "lldb/API/SBDebugger.h"
  36 #include "lldb/API/SBEvent.h"
  37 #include "lldb/API/SBFile.h"
  38 #include "lldb/API/SBFileSpec.h"
  39 #include "lldb/API/SBMemoryRegionInfo.h"
  40 #include "lldb/API/SBMemoryRegionInfoList.h"
  41 #include "lldb/API/SBScriptObject.h"
  42 #include "lldb/API/SBStream.h"
  43 #include "lldb/API/SBStringList.h"
  44 #include "lldb/API/SBStructuredData.h"
  45 #include "lldb/API/SBThread.h"
  46 #include "lldb/API/SBThreadCollection.h"
  47 #include "lldb/API/SBTrace.h"
  48 #include "lldb/API/SBUnixSignals.h"
  49
  50 using namespace lldb;
  51 using namespace lldb_private;
  52
  53 SBProcess::SBProcess() { LLDB_INSTRUMENT_VA(this); }
  54
  55 // SBProcess constructor
  56
  57 SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
  58   LLDB_INSTRUMENT_VA(this, rhs);
  59 }
  60
  61 SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
  62     : m_opaque_wp(process_sp) {
  63   LLDB_INSTRUMENT_VA(this, process_sp);
  64 }
  65
  66 const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
  67   LLDB_INSTRUMENT_VA(this, rhs);
  68
  69   if (this != &rhs)
  70     m_opaque_wp = rhs.m_opaque_wp;
  71   return *this;
  72 }
  73
  74 // Destructor
  75 SBProcess::~SBProcess() = default;
  76
  77 const char *SBProcess::GetBroadcasterClassName() {
  78   LLDB_INSTRUMENT();
  79
  80   return Process::GetStaticBroadcasterClass().AsCString();
  81 }
  82
  83 const char *SBProcess::GetPluginName() {
  84   LLDB_INSTRUMENT_VA(this);
  85
  86   ProcessSP process_sp(GetSP());
  87   if (process_sp) {
  88     return ConstString(process_sp->GetPluginName()).GetCString();
  89   }
  90   return "<Unknown>";
  91 }
  92
  93 const char *SBProcess::GetShortPluginName() {
  94   LLDB_INSTRUMENT_VA(this);
  95
  96   ProcessSP process_sp(GetSP());
  97   if (process_sp) {
  98     return ConstString(process_sp->GetPluginName()).GetCString();
  99   }
 100   return "<Unknown>";
 101 }
 102
 103 lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
 104
 105 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 106
 107 void SBProcess::Clear() {
 108   LLDB_INSTRUMENT_VA(this);
 109
 110   m_opaque_wp.reset();
 111 }
 112
 113 bool SBProcess::IsValid() const {
 114   LLDB_INSTRUMENT_VA(this);
 115   return this->operator bool();
 116 }
 117 SBProcess::operator bool() const {
 118   LLDB_INSTRUMENT_VA(this);
 119
 120   ProcessSP process_sp(m_opaque_wp.lock());
 121   return ((bool)process_sp && process_sp->IsValid());
 122 }
 123
 124 bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
 125                              const char *stdin_path, const char *stdout_path,
 126                              const char *stderr_path,
 127                              const char *working_directory,
 128                              uint32_t launch_flags, bool stop_at_entry,
 129                              lldb::SBError &error) {
 130   LLDB_INSTRUMENT_VA(this, argv, envp, stdin_path, stdout_path, stderr_path,
 131                      working_directory, launch_flags, stop_at_entry, error);
 132
 133   ProcessSP process_sp(GetSP());
 134   if (process_sp) {
 135     std::lock_guard<std::recursive_mutex> guard(
 136         process_sp->GetTarget().GetAPIMutex());
 137     if (process_sp->GetState() == eStateConnected) {
 138       if (stop_at_entry)
 139         launch_flags |= eLaunchFlagStopAtEntry;
 140       ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path),
 141                                     FileSpec(stderr_path),
 142                                     FileSpec(working_directory), launch_flags);
 143       Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
 144       if (exe_module)
 145         launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
 146       if (argv)
 147         launch_info.GetArguments().AppendArguments(argv);
 148       if (envp)
 149         launch_info.GetEnvironment() = Environment(envp);
 150       error.SetError(process_sp->Launch(launch_info));
 151     } else {
 152       error.SetErrorString("must be in eStateConnected to call RemoteLaunch");
 153     }
 154   } else {
 155     error.SetErrorString("unable to attach pid");
 156   }
 157
 158   return error.Success();
 159 }
 160
 161 bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
 162                                             lldb::SBError &error) {
 163   LLDB_INSTRUMENT_VA(this, pid, error);
 164
 165   ProcessSP process_sp(GetSP());
 166   if (process_sp) {
 167     std::lock_guard<std::recursive_mutex> guard(
 168         process_sp->GetTarget().GetAPIMutex());
 169     if (process_sp->GetState() == eStateConnected) {
 170       ProcessAttachInfo attach_info;
 171       attach_info.SetProcessID(pid);
 172       error.SetError(process_sp->Attach(attach_info));
 173     } else {
 174       error.SetErrorString(
 175           "must be in eStateConnected to call RemoteAttachToProcessWithID");
 176     }
 177   } else {
 178     error.SetErrorString("unable to attach pid");
 179   }
 180
 181   return error.Success();
 182 }
 183
 184 uint32_t SBProcess::GetNumThreads() {
 185   LLDB_INSTRUMENT_VA(this);
 186
 187   uint32_t num_threads = 0;
 188   ProcessSP process_sp(GetSP());
 189   if (process_sp) {
 190     Process::StopLocker stop_locker;
 191
 192     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
 193     std::lock_guard<std::recursive_mutex> guard(
 194         process_sp->GetTarget().GetAPIMutex());
 195     num_threads = process_sp->GetThreadList().GetSize(can_update);
 196   }
 197
 198   return num_threads;
 199 }
 200
 201 SBThread SBProcess::GetSelectedThread() const {
 202   LLDB_INSTRUMENT_VA(this);
 203
 204   SBThread sb_thread;
 205   ThreadSP thread_sp;
 206   ProcessSP process_sp(GetSP());
 207   if (process_sp) {
 208     std::lock_guard<std::recursive_mutex> guard(
 209         process_sp->GetTarget().GetAPIMutex());
 210     thread_sp = process_sp->GetThreadList().GetSelectedThread();
 211     sb_thread.SetThread(thread_sp);
 212   }
 213
 214   return sb_thread;
 215 }
 216
 217 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
 218                                          lldb::addr_t context) {
 219   LLDB_INSTRUMENT_VA(this, tid, context);
 220
 221   SBThread sb_thread;
 222   ThreadSP thread_sp;
 223   ProcessSP process_sp(GetSP());
 224   if (process_sp) {
 225     std::lock_guard<std::recursive_mutex> guard(
 226         process_sp->GetTarget().GetAPIMutex());
 227     thread_sp = process_sp->CreateOSPluginThread(tid, context);
 228     sb_thread.SetThread(thread_sp);
 229   }
 230
 231   return sb_thread;
 232 }
 233
 234 SBTarget SBProcess::GetTarget() const {
 235   LLDB_INSTRUMENT_VA(this);
 236
 237   SBTarget sb_target;
 238   TargetSP target_sp;
 239   ProcessSP process_sp(GetSP());
 240   if (process_sp) {
 241     target_sp = process_sp->GetTarget().shared_from_this();
 242     sb_target.SetSP(target_sp);
 243   }
 244
 245   return sb_target;
 246 }
 247
 248 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
 249   LLDB_INSTRUMENT_VA(this, src, src_len);
 250
 251   size_t ret_val = 0;
 252   ProcessSP process_sp(GetSP());
 253   if (process_sp) {
 254     Status error;
 255     ret_val = process_sp->PutSTDIN(src, src_len, error);
 256   }
 257
 258   return ret_val;
 259 }
 260
 261 size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
 262   LLDB_INSTRUMENT_VA(this, dst, dst_len);
 263
 264   size_t bytes_read = 0;
 265   ProcessSP process_sp(GetSP());
 266   if (process_sp) {
 267     Status error;
 268     bytes_read = process_sp->GetSTDOUT(dst, dst_len, error);
 269   }
 270
 271   return bytes_read;
 272 }
 273
 274 size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
 275   LLDB_INSTRUMENT_VA(this, dst, dst_len);
 276
 277   size_t bytes_read = 0;
 278   ProcessSP process_sp(GetSP());
 279   if (process_sp) {
 280     Status error;
 281     bytes_read = process_sp->GetSTDERR(dst, dst_len, error);
 282   }
 283
 284   return bytes_read;
 285 }
 286
 287 size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
 288   LLDB_INSTRUMENT_VA(this, dst, dst_len);
 289
 290   size_t bytes_read = 0;
 291   ProcessSP process_sp(GetSP());
 292   if (process_sp) {
 293     Status error;
 294     bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error);
 295   }
 296
 297   return bytes_read;
 298 }
 299
 300 void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const {
 301   LLDB_INSTRUMENT_VA(this, event, out);
 302
 303   return ReportEventState(event, out.m_opaque_sp);
 304 }
 305
 306 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
 307   LLDB_INSTRUMENT_VA(this, event, out);
 308   FileSP outfile = std::make_shared<NativeFile>(out, false);
 309   return ReportEventState(event, outfile);
 310 }
 311
 312 void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
 313
 314   LLDB_INSTRUMENT_VA(this, event, out);
 315
 316   if (!out || !out->IsValid())
 317     return;
 318
 319   ProcessSP process_sp(GetSP());
 320   if (process_sp) {
 321     StreamFile stream(out);
 322     const StateType event_state = SBProcess::GetStateFromEvent(event);
 323     stream.Printf("Process %" PRIu64 " %s\n",
 324         process_sp->GetID(), SBDebugger::StateAsCString(event_state));
 325   }
 326 }
 327
 328 void SBProcess::AppendEventStateReport(const SBEvent &event,
 329                                        SBCommandReturnObject &result) {
 330   LLDB_INSTRUMENT_VA(this, event, result);
 331
 332   ProcessSP process_sp(GetSP());
 333   if (process_sp) {
 334     const StateType event_state = SBProcess::GetStateFromEvent(event);
 335     char message[1024];
 336     ::snprintf(message, sizeof(message), "Process %" PRIu64 " %s\n",
 337                process_sp->GetID(), SBDebugger::StateAsCString(event_state));
 338
 339     result.AppendMessage(message);
 340   }
 341 }
 342
 343 bool SBProcess::SetSelectedThread(const SBThread &thread) {
 344   LLDB_INSTRUMENT_VA(this, thread);
 345
 346   ProcessSP process_sp(GetSP());
 347   if (process_sp) {
 348     std::lock_guard<std::recursive_mutex> guard(
 349         process_sp->GetTarget().GetAPIMutex());
 350     return process_sp->GetThreadList().SetSelectedThreadByID(
 351         thread.GetThreadID());
 352   }
 353   return false;
 354 }
 355
 356 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
 357   LLDB_INSTRUMENT_VA(this, tid);
 358
 359   bool ret_val = false;
 360   ProcessSP process_sp(GetSP());
 361   if (process_sp) {
 362     std::lock_guard<std::recursive_mutex> guard(
 363         process_sp->GetTarget().GetAPIMutex());
 364     ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid);
 365   }
 366
 367   return ret_val;
 368 }
 369
 370 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
 371   LLDB_INSTRUMENT_VA(this, index_id);
 372
 373   bool ret_val = false;
 374   ProcessSP process_sp(GetSP());
 375   if (process_sp) {
 376     std::lock_guard<std::recursive_mutex> guard(
 377         process_sp->GetTarget().GetAPIMutex());
 378     ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id);
 379   }
 380
 381
 382   return ret_val;
 383 }
 384
 385 SBThread SBProcess::GetThreadAtIndex(size_t index) {
 386   LLDB_INSTRUMENT_VA(this, index);
 387
 388   SBThread sb_thread;
 389   ThreadSP thread_sp;
 390   ProcessSP process_sp(GetSP());
 391   if (process_sp) {
 392     Process::StopLocker stop_locker;
 393     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
 394     std::lock_guard<std::recursive_mutex> guard(
 395         process_sp->GetTarget().GetAPIMutex());
 396     thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
 397     sb_thread.SetThread(thread_sp);
 398   }
 399
 400   return sb_thread;
 401 }
 402
 403 uint32_t SBProcess::GetNumQueues() {
 404   LLDB_INSTRUMENT_VA(this);
 405
 406   uint32_t num_queues = 0;
 407   ProcessSP process_sp(GetSP());
 408   if (process_sp) {
 409     Process::StopLocker stop_locker;
 410     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 411       std::lock_guard<std::recursive_mutex> guard(
 412           process_sp->GetTarget().GetAPIMutex());
 413       num_queues = process_sp->GetQueueList().GetSize();
 414     }
 415   }
 416
 417   return num_queues;
 418 }
 419
 420 SBQueue SBProcess::GetQueueAtIndex(size_t index) {
 421   LLDB_INSTRUMENT_VA(this, index);
 422
 423   SBQueue sb_queue;
 424   QueueSP queue_sp;
 425   ProcessSP process_sp(GetSP());
 426   if (process_sp) {
 427     Process::StopLocker stop_locker;
 428     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 429       std::lock_guard<std::recursive_mutex> guard(
 430           process_sp->GetTarget().GetAPIMutex());
 431       queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
 432       sb_queue.SetQueue(queue_sp);
 433     }
 434   }
 435
 436   return sb_queue;
 437 }
 438
 439 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
 440   LLDB_INSTRUMENT_VA(this, include_expression_stops);
 441
 442   ProcessSP process_sp(GetSP());
 443   if (process_sp) {
 444     std::lock_guard<std::recursive_mutex> guard(
 445         process_sp->GetTarget().GetAPIMutex());
 446     if (include_expression_stops)
 447       return process_sp->GetStopID();
 448     else
 449       return process_sp->GetLastNaturalStopID();
 450   }
 451   return 0;
 452 }
 453
 454 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
 455   LLDB_INSTRUMENT_VA(this, stop_id);
 456
 457   SBEvent sb_event;
 458   EventSP event_sp;
 459   ProcessSP process_sp(GetSP());
 460   if (process_sp) {
 461     std::lock_guard<std::recursive_mutex> guard(
 462         process_sp->GetTarget().GetAPIMutex());
 463     event_sp = process_sp->GetStopEventForStopID(stop_id);
 464     sb_event.reset(event_sp);
 465   }
 466
 467   return sb_event;
 468 }
 469
 470 void SBProcess::ForceScriptedState(StateType new_state) {
 471   LLDB_INSTRUMENT_VA(this, new_state);
 472
 473   if (ProcessSP process_sp = GetSP()) {
 474     std::lock_guard<std::recursive_mutex> guard(
 475         process_sp->GetTarget().GetAPIMutex());
 476     process_sp->ForceScriptedState(new_state);
 477   }
 478 }
 479
 480 StateType SBProcess::GetState() {
 481   LLDB_INSTRUMENT_VA(this);
 482
 483   StateType ret_val = eStateInvalid;
 484   ProcessSP process_sp(GetSP());
 485   if (process_sp) {
 486     std::lock_guard<std::recursive_mutex> guard(
 487         process_sp->GetTarget().GetAPIMutex());
 488     ret_val = process_sp->GetState();
 489   }
 490
 491   return ret_val;
 492 }
 493
 494 int SBProcess::GetExitStatus() {
 495   LLDB_INSTRUMENT_VA(this);
 496
 497   int exit_status = 0;
 498   ProcessSP process_sp(GetSP());
 499   if (process_sp) {
 500     std::lock_guard<std::recursive_mutex> guard(
 501         process_sp->GetTarget().GetAPIMutex());
 502     exit_status = process_sp->GetExitStatus();
 503   }
 504
 505   return exit_status;
 506 }
 507
 508 const char *SBProcess::GetExitDescription() {
 509   LLDB_INSTRUMENT_VA(this);
 510
 511   ProcessSP process_sp(GetSP());
 512   if (!process_sp)
 513     return nullptr;
 514
 515   std::lock_guard<std::recursive_mutex> guard(
 516       process_sp->GetTarget().GetAPIMutex());
 517   return ConstString(process_sp->GetExitDescription()).GetCString();
 518 }
 519
 520 lldb::pid_t SBProcess::GetProcessID() {
 521   LLDB_INSTRUMENT_VA(this);
 522
 523   lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
 524   ProcessSP process_sp(GetSP());
 525   if (process_sp)
 526     ret_val = process_sp->GetID();
 527
 528   return ret_val;
 529 }
 530
 531 uint32_t SBProcess::GetUniqueID() {
 532   LLDB_INSTRUMENT_VA(this);
 533
 534   uint32_t ret_val = 0;
 535   ProcessSP process_sp(GetSP());
 536   if (process_sp)
 537     ret_val = process_sp->GetUniqueID();
 538   return ret_val;
 539 }
 540
 541 ByteOrder SBProcess::GetByteOrder() const {
 542   LLDB_INSTRUMENT_VA(this);
 543
 544   ByteOrder byteOrder = eByteOrderInvalid;
 545   ProcessSP process_sp(GetSP());
 546   if (process_sp)
 547     byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
 548
 549
 550   return byteOrder;
 551 }
 552
 553 uint32_t SBProcess::GetAddressByteSize() const {
 554   LLDB_INSTRUMENT_VA(this);
 555
 556   uint32_t size = 0;
 557   ProcessSP process_sp(GetSP());
 558   if (process_sp)
 559     size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
 560
 561
 562   return size;
 563 }
 564
 565 SBError SBProcess::Continue() {
 566   LLDB_INSTRUMENT_VA(this);
 567
 568   SBError sb_error;
 569   ProcessSP process_sp(GetSP());
 570
 571   if (process_sp) {
 572     std::lock_guard<std::recursive_mutex> guard(
 573         process_sp->GetTarget().GetAPIMutex());
 574
 575     if (process_sp->GetTarget().GetDebugger().GetAsyncExecution())
 576       sb_error.ref() = process_sp->Resume();
 577     else
 578       sb_error.ref() = process_sp->ResumeSynchronous(nullptr);
 579   } else
 580     sb_error.SetErrorString("SBProcess is invalid");
 581
 582   return sb_error;
 583 }
 584
 585 SBError SBProcess::Destroy() {
 586   LLDB_INSTRUMENT_VA(this);
 587
 588   SBError sb_error;
 589   ProcessSP process_sp(GetSP());
 590   if (process_sp) {
 591     std::lock_guard<std::recursive_mutex> guard(
 592         process_sp->GetTarget().GetAPIMutex());
 593     sb_error.SetError(process_sp->Destroy(false));
 594   } else
 595     sb_error.SetErrorString("SBProcess is invalid");
 596
 597   return sb_error;
 598 }
 599
 600 SBError SBProcess::Stop() {
 601   LLDB_INSTRUMENT_VA(this);
 602
 603   SBError sb_error;
 604   ProcessSP process_sp(GetSP());
 605   if (process_sp) {
 606     std::lock_guard<std::recursive_mutex> guard(
 607         process_sp->GetTarget().GetAPIMutex());
 608     sb_error.SetError(process_sp->Halt());
 609   } else
 610     sb_error.SetErrorString("SBProcess is invalid");
 611
 612   return sb_error;
 613 }
 614
 615 SBError SBProcess::Kill() {
 616   LLDB_INSTRUMENT_VA(this);
 617
 618   SBError sb_error;
 619   ProcessSP process_sp(GetSP());
 620   if (process_sp) {
 621     std::lock_guard<std::recursive_mutex> guard(
 622         process_sp->GetTarget().GetAPIMutex());
 623     sb_error.SetError(process_sp->Destroy(true));
 624   } else
 625     sb_error.SetErrorString("SBProcess is invalid");
 626
 627   return sb_error;
 628 }
 629
 630 SBError SBProcess::Detach() {
 631   LLDB_INSTRUMENT_VA(this);
 632
 633   // FIXME: This should come from a process default.
 634   bool keep_stopped = false;
 635   return Detach(keep_stopped);
 636 }
 637
 638 SBError SBProcess::Detach(bool keep_stopped) {
 639   LLDB_INSTRUMENT_VA(this, keep_stopped);
 640
 641   SBError sb_error;
 642   ProcessSP process_sp(GetSP());
 643   if (process_sp) {
 644     std::lock_guard<std::recursive_mutex> guard(
 645         process_sp->GetTarget().GetAPIMutex());
 646     sb_error.SetError(process_sp->Detach(keep_stopped));
 647   } else
 648     sb_error.SetErrorString("SBProcess is invalid");
 649
 650   return sb_error;
 651 }
 652
 653 SBError SBProcess::Signal(int signo) {
 654   LLDB_INSTRUMENT_VA(this, signo);
 655
 656   SBError sb_error;
 657   ProcessSP process_sp(GetSP());
 658   if (process_sp) {
 659     std::lock_guard<std::recursive_mutex> guard(
 660         process_sp->GetTarget().GetAPIMutex());
 661     sb_error.SetError(process_sp->Signal(signo));
 662   } else
 663     sb_error.SetErrorString("SBProcess is invalid");
 664
 665   return sb_error;
 666 }
 667
 668 SBUnixSignals SBProcess::GetUnixSignals() {
 669   LLDB_INSTRUMENT_VA(this);
 670
 671   if (auto process_sp = GetSP())
 672     return SBUnixSignals{process_sp};
 673
 674   return SBUnixSignals{};
 675 }
 676
 677 void SBProcess::SendAsyncInterrupt() {
 678   LLDB_INSTRUMENT_VA(this);
 679
 680   ProcessSP process_sp(GetSP());
 681   if (process_sp) {
 682     process_sp->SendAsyncInterrupt();
 683   }
 684 }
 685
 686 SBThread SBProcess::GetThreadByID(tid_t tid) {
 687   LLDB_INSTRUMENT_VA(this, tid);
 688
 689   SBThread sb_thread;
 690   ThreadSP thread_sp;
 691   ProcessSP process_sp(GetSP());
 692   if (process_sp) {
 693     Process::StopLocker stop_locker;
 694     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
 695     std::lock_guard<std::recursive_mutex> guard(
 696         process_sp->GetTarget().GetAPIMutex());
 697     thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update);
 698     sb_thread.SetThread(thread_sp);
 699   }
 700
 701   return sb_thread;
 702 }
 703
 704 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
 705   LLDB_INSTRUMENT_VA(this, index_id);
 706
 707   SBThread sb_thread;
 708   ThreadSP thread_sp;
 709   ProcessSP process_sp(GetSP());
 710   if (process_sp) {
 711     Process::StopLocker stop_locker;
 712     const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
 713     std::lock_guard<std::recursive_mutex> guard(
 714         process_sp->GetTarget().GetAPIMutex());
 715     thread_sp =
 716         process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update);
 717     sb_thread.SetThread(thread_sp);
 718   }
 719
 720   return sb_thread;
 721 }
 722
 723 StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
 724   LLDB_INSTRUMENT_VA(event);
 725
 726   StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
 727
 728   return ret_val;
 729 }
 730
 731 bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
 732   LLDB_INSTRUMENT_VA(event);
 733
 734   bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
 735
 736   return ret_val;
 737 }
 738
 739 size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
 740   LLDB_INSTRUMENT_VA(event);
 741
 742   return Process::ProcessEventData::GetNumRestartedReasons(event.get());
 743 }
 744
 745 const char *
 746 SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event,
 747                                               size_t idx) {
 748   LLDB_INSTRUMENT_VA(event, idx);
 749
 750   return ConstString(Process::ProcessEventData::GetRestartedReasonAtIndex(
 751                          event.get(), idx))
 752       .GetCString();
 753 }
 754
 755 SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
 756   LLDB_INSTRUMENT_VA(event);
 757
 758   ProcessSP process_sp =
 759       Process::ProcessEventData::GetProcessFromEvent(event.get());
 760   if (!process_sp) {
 761     // StructuredData events also know the process they come from. Try that.
 762     process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
 763   }
 764
 765   return SBProcess(process_sp);
 766 }
 767
 768 bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
 769   LLDB_INSTRUMENT_VA(event);
 770
 771   return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
 772 }
 773
 774 lldb::SBStructuredData
 775 SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
 776   LLDB_INSTRUMENT_VA(event);
 777
 778   return SBStructuredData(event.GetSP());
 779 }
 780
 781 bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
 782   LLDB_INSTRUMENT_VA(event);
 783
 784   return Process::ProcessEventData::GetEventDataFromEvent(event.get()) !=
 785          nullptr;
 786 }
 787
 788 bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
 789   LLDB_INSTRUMENT_VA(event);
 790
 791   EventSP event_sp = event.GetSP();
 792   EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
 793   return event_data && (event_data->GetFlavor() ==
 794                         EventDataStructuredData::GetFlavorString());
 795 }
 796
 797 SBBroadcaster SBProcess::GetBroadcaster() const {
 798   LLDB_INSTRUMENT_VA(this);
 799
 800   ProcessSP process_sp(GetSP());
 801
 802   SBBroadcaster broadcaster(process_sp.get(), false);
 803
 804   return broadcaster;
 805 }
 806
 807 const char *SBProcess::GetBroadcasterClass() {
 808   LLDB_INSTRUMENT();
 809
 810   return Process::GetStaticBroadcasterClass().AsCString();
 811 }
 812
 813 size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
 814                              SBError &sb_error) {
 815   LLDB_INSTRUMENT_VA(this, addr, dst, dst_len, sb_error);
 816
 817   if (!dst) {
 818     sb_error.SetErrorStringWithFormat(
 819         "no buffer provided to read %zu bytes into", dst_len);
 820     return 0;
 821   }
 822
 823   size_t bytes_read = 0;
 824   ProcessSP process_sp(GetSP());
 825
 826
 827   if (process_sp) {
 828     Process::StopLocker stop_locker;
 829     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 830       std::lock_guard<std::recursive_mutex> guard(
 831           process_sp->GetTarget().GetAPIMutex());
 832       bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref());
 833     } else {
 834       sb_error.SetErrorString("process is running");
 835     }
 836   } else {
 837     sb_error.SetErrorString("SBProcess is invalid");
 838   }
 839
 840   return bytes_read;
 841 }
 842
 843 size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
 844                                         lldb::SBError &sb_error) {
 845   LLDB_INSTRUMENT_VA(this, addr, buf, size, sb_error);
 846
 847   size_t bytes_read = 0;
 848   ProcessSP process_sp(GetSP());
 849   if (process_sp) {
 850     Process::StopLocker stop_locker;
 851     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 852       std::lock_guard<std::recursive_mutex> guard(
 853           process_sp->GetTarget().GetAPIMutex());
 854       bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size,
 855                                                      sb_error.ref());
 856     } else {
 857       sb_error.SetErrorString("process is running");
 858     }
 859   } else {
 860     sb_error.SetErrorString("SBProcess is invalid");
 861   }
 862   return bytes_read;
 863 }
 864
 865 uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
 866                                            lldb::SBError &sb_error) {
 867   LLDB_INSTRUMENT_VA(this, addr, byte_size, sb_error);
 868
 869   uint64_t value = 0;
 870   ProcessSP process_sp(GetSP());
 871   if (process_sp) {
 872     Process::StopLocker stop_locker;
 873     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 874       std::lock_guard<std::recursive_mutex> guard(
 875           process_sp->GetTarget().GetAPIMutex());
 876       value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
 877                                                         sb_error.ref());
 878     } else {
 879       sb_error.SetErrorString("process is running");
 880     }
 881   } else {
 882     sb_error.SetErrorString("SBProcess is invalid");
 883   }
 884   return value;
 885 }
 886
 887 lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
 888                                               lldb::SBError &sb_error) {
 889   LLDB_INSTRUMENT_VA(this, addr, sb_error);
 890
 891   lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
 892   ProcessSP process_sp(GetSP());
 893   if (process_sp) {
 894     Process::StopLocker stop_locker;
 895     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 896       std::lock_guard<std::recursive_mutex> guard(
 897           process_sp->GetTarget().GetAPIMutex());
 898       ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref());
 899     } else {
 900       sb_error.SetErrorString("process is running");
 901     }
 902   } else {
 903     sb_error.SetErrorString("SBProcess is invalid");
 904   }
 905   return ptr;
 906 }
 907
 908 size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
 909                               SBError &sb_error) {
 910   LLDB_INSTRUMENT_VA(this, addr, src, src_len, sb_error);
 911
 912   size_t bytes_written = 0;
 913
 914   ProcessSP process_sp(GetSP());
 915
 916   if (process_sp) {
 917     Process::StopLocker stop_locker;
 918     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
 919       std::lock_guard<std::recursive_mutex> guard(
 920           process_sp->GetTarget().GetAPIMutex());
 921       bytes_written =
 922           process_sp->WriteMemory(addr, src, src_len, sb_error.ref());
 923     } else {
 924       sb_error.SetErrorString("process is running");
 925     }
 926   }
 927
 928   return bytes_written;
 929 }
 930
 931 bool SBProcess::GetDescription(SBStream &description) {
 932   LLDB_INSTRUMENT_VA(this, description);
 933
 934   Stream &strm = description.ref();
 935
 936   ProcessSP process_sp(GetSP());
 937   if (process_sp) {
 938     char path[PATH_MAX];
 939     GetTarget().GetExecutable().GetPath(path, sizeof(path));
 940     Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
 941     const char *exe_name = nullptr;
 942     if (exe_module)
 943       exe_name = exe_module->GetFileSpec().GetFilename().AsCString();
 944
 945     strm.Printf("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s",
 946                 process_sp->GetID(), lldb_private::StateAsCString(GetState()),
 947                 GetNumThreads(), exe_name ? ", executable = " : "",
 948                 exe_name ? exe_name : "");
 949   } else
 950     strm.PutCString("No value");
 951
 952   return true;
 953 }
 954
 955 SBStructuredData SBProcess::GetExtendedCrashInformation() {
 956   LLDB_INSTRUMENT_VA(this);
 957   SBStructuredData data;
 958   ProcessSP process_sp(GetSP());
 959   if (!process_sp)
 960     return data;
 961
 962   PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
 963
 964   if (!platform_sp)
 965     return data;
 966
 967   auto expected_data =
 968       platform_sp->FetchExtendedCrashInformation(*process_sp.get());
 969
 970   if (!expected_data)
 971     return data;
 972
 973   StructuredData::ObjectSP fetched_data = *expected_data;
 974   data.m_impl_up->SetObjectSP(fetched_data);
 975   return data;
 976 }
 977
 978 uint32_t
 979 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
 980   LLDB_INSTRUMENT_VA(this, sb_error);
 981
 982   uint32_t num = 0;
 983   ProcessSP process_sp(GetSP());
 984   if (process_sp) {
 985     std::lock_guard<std::recursive_mutex> guard(
 986         process_sp->GetTarget().GetAPIMutex());
 987     std::optional<uint32_t> actual_num = process_sp->GetWatchpointSlotCount();
 988     if (actual_num) {
 989       num = *actual_num;
 990     } else {
 991       sb_error.SetErrorString("Unable to determine number of watchpoints");
 992     }
 993   } else {
 994     sb_error.SetErrorString("SBProcess is invalid");
 995   }
 996   return num;
 997 }
 998
 999 uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
1000                               lldb::SBError &sb_error) {
1001   LLDB_INSTRUMENT_VA(this, sb_remote_image_spec, sb_error);
1002
1003   return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
1004 }
1005
1006 uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
1007                               const lldb::SBFileSpec &sb_remote_image_spec,
1008                               lldb::SBError &sb_error) {
1009   LLDB_INSTRUMENT_VA(this, sb_local_image_spec, sb_remote_image_spec, sb_error);
1010
1011   ProcessSP process_sp(GetSP());
1012   if (process_sp) {
1013     Process::StopLocker stop_locker;
1014     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
1015       std::lock_guard<std::recursive_mutex> guard(
1016         process_sp->GetTarget().GetAPIMutex());
1017       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1018       return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec,
1019                                     *sb_remote_image_spec, sb_error.ref());
1020     } else {
1021       sb_error.SetErrorString("process is running");
1022     }
1023   } else {
1024     sb_error.SetErrorString("process is invalid");
1025   }
1026   return LLDB_INVALID_IMAGE_TOKEN;
1027 }
1028
1029 uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
1030                                         SBStringList &paths,
1031                                         lldb::SBFileSpec &loaded_path,
1032                                         lldb::SBError &error) {
1033   LLDB_INSTRUMENT_VA(this, image_spec, paths, loaded_path, error);
1034
1035   ProcessSP process_sp(GetSP());
1036   if (process_sp) {
1037     Process::StopLocker stop_locker;
1038     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
1039       std::lock_guard<std::recursive_mutex> guard(
1040         process_sp->GetTarget().GetAPIMutex());
1041       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1042       size_t num_paths = paths.GetSize();
1043       std::vector<std::string> paths_vec;
1044       paths_vec.reserve(num_paths);
1045       for (size_t i = 0; i < num_paths; i++)
1046         paths_vec.push_back(paths.GetStringAtIndex(i));
1047       FileSpec loaded_spec;
1048
1049       uint32_t token = platform_sp->LoadImageUsingPaths(
1050           process_sp.get(), *image_spec, paths_vec, error.ref(), &loaded_spec);
1051       if (token != LLDB_INVALID_IMAGE_TOKEN)
1052         loaded_path = loaded_spec;
1053       return token;
1054     } else {
1055       error.SetErrorString("process is running");
1056     }
1057   } else {
1058     error.SetErrorString("process is invalid");
1059   }
1060
1061   return LLDB_INVALID_IMAGE_TOKEN;
1062 }
1063
1064 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
1065   LLDB_INSTRUMENT_VA(this, image_token);
1066
1067   lldb::SBError sb_error;
1068   ProcessSP process_sp(GetSP());
1069   if (process_sp) {
1070     Process::StopLocker stop_locker;
1071     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
1072       std::lock_guard<std::recursive_mutex> guard(
1073           process_sp->GetTarget().GetAPIMutex());
1074       PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1075       sb_error.SetError(
1076           platform_sp->UnloadImage(process_sp.get(), image_token));
1077     } else {
1078       sb_error.SetErrorString("process is running");
1079     }
1080   } else
1081     sb_error.SetErrorString("invalid process");
1082   return sb_error;
1083 }
1084
1085 lldb::SBError SBProcess::SendEventData(const char *event_data) {
1086   LLDB_INSTRUMENT_VA(this, event_data);
1087
1088   lldb::SBError sb_error;
1089   ProcessSP process_sp(GetSP());
1090   if (process_sp) {
1091     Process::StopLocker stop_locker;
1092     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
1093       std::lock_guard<std::recursive_mutex> guard(
1094           process_sp->GetTarget().GetAPIMutex());
1095       sb_error.SetError(process_sp->SendEventData(event_data));
1096     } else {
1097       sb_error.SetErrorString("process is running");
1098     }
1099   } else
1100     sb_error.SetErrorString("invalid process");
1101   return sb_error;
1102 }
1103
1104 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
1105   LLDB_INSTRUMENT_VA(this);
1106
1107   ProcessSP process_sp(GetSP());
1108   if (process_sp && process_sp->GetSystemRuntime()) {
1109     SystemRuntime *runtime = process_sp->GetSystemRuntime();
1110     return runtime->GetExtendedBacktraceTypes().size();
1111   }
1112   return 0;
1113 }
1114
1115 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
1116   LLDB_INSTRUMENT_VA(this, idx);
1117
1118   ProcessSP process_sp(GetSP());
1119   if (process_sp && process_sp->GetSystemRuntime()) {
1120     SystemRuntime *runtime = process_sp->GetSystemRuntime();
1121     const std::vector<ConstString> &names =
1122         runtime->GetExtendedBacktraceTypes();
1123     if (idx < names.size()) {
1124       return names[idx].AsCString();
1125     }
1126   }
1127   return nullptr;
1128 }
1129
1130 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
1131   LLDB_INSTRUMENT_VA(this, addr);
1132
1133   ProcessSP process_sp(GetSP());
1134   SBThreadCollection threads;
1135   if (process_sp) {
1136     threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
1137   }
1138   return threads;
1139 }
1140
1141 bool SBProcess::IsInstrumentationRuntimePresent(
1142     InstrumentationRuntimeType type) {
1143   LLDB_INSTRUMENT_VA(this, type);
1144
1145   ProcessSP process_sp(GetSP());
1146   if (!process_sp)
1147     return false;
1148
1149   std::lock_guard<std::recursive_mutex> guard(
1150       process_sp->GetTarget().GetAPIMutex());
1151
1152   InstrumentationRuntimeSP runtime_sp =
1153       process_sp->GetInstrumentationRuntime(type);
1154
1155   if (!runtime_sp.get())
1156     return false;
1157
1158   return runtime_sp->IsActive();
1159 }
1160
1161 lldb::SBError SBProcess::SaveCore(const char *file_name) {
1162   LLDB_INSTRUMENT_VA(this, file_name);
1163   return SaveCore(file_name, "", SaveCoreStyle::eSaveCoreFull);
1164 }
1165
1166 lldb::SBError SBProcess::SaveCore(const char *file_name,
1167                                   const char *flavor,
1168                                   SaveCoreStyle core_style) {
1169   LLDB_INSTRUMENT_VA(this, file_name, flavor, core_style);
1170
1171   lldb::SBError error;
1172   ProcessSP process_sp(GetSP());
1173   if (!process_sp) {
1174     error.SetErrorString("SBProcess is invalid");
1175     return error;
1176   }
1177
1178   std::lock_guard<std::recursive_mutex> guard(
1179       process_sp->GetTarget().GetAPIMutex());
1180
1181   if (process_sp->GetState() != eStateStopped) {
1182     error.SetErrorString("the process is not stopped");
1183     return error;
1184   }
1185
1186   FileSpec core_file(file_name);
1187   FileSystem::Instance().Resolve(core_file);
1188   error.ref() = PluginManager::SaveCore(process_sp, core_file, core_style,
1189                                         flavor);
1190
1191   return error;
1192 }
1193
1194 lldb::SBError
1195 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
1196                                SBMemoryRegionInfo &sb_region_info) {
1197   LLDB_INSTRUMENT_VA(this, load_addr, sb_region_info);
1198
1199   lldb::SBError sb_error;
1200   ProcessSP process_sp(GetSP());
1201   if (process_sp) {
1202     Process::StopLocker stop_locker;
1203     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
1204       std::lock_guard<std::recursive_mutex> guard(
1205           process_sp->GetTarget().GetAPIMutex());
1206
1207       sb_error.ref() =
1208           process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref());
1209     } else {
1210       sb_error.SetErrorString("process is running");
1211     }
1212   } else {
1213     sb_error.SetErrorString("SBProcess is invalid");
1214   }
1215   return sb_error;
1216 }
1217
1218 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
1219   LLDB_INSTRUMENT_VA(this);
1220
1221   lldb::SBMemoryRegionInfoList sb_region_list;
1222
1223   ProcessSP process_sp(GetSP());
1224   Process::StopLocker stop_locker;
1225   if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
1226     std::lock_guard<std::recursive_mutex> guard(
1227         process_sp->GetTarget().GetAPIMutex());
1228
1229     process_sp->GetMemoryRegions(sb_region_list.ref());
1230   }
1231
1232   return sb_region_list;
1233 }
1234
1235 lldb::SBProcessInfo SBProcess::GetProcessInfo() {
1236   LLDB_INSTRUMENT_VA(this);
1237
1238   lldb::SBProcessInfo sb_proc_info;
1239   ProcessSP process_sp(GetSP());
1240   ProcessInstanceInfo proc_info;
1241   if (process_sp && process_sp->GetProcessInfo(proc_info)) {
1242     sb_proc_info.SetProcessInfo(proc_info);
1243   }
1244   return sb_proc_info;
1245 }
1246
1247 lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
1248                                        lldb::SBError &sb_error) {
1249   LLDB_INSTRUMENT_VA(this, size, permissions, sb_error);
1250
1251   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
1252   ProcessSP process_sp(GetSP());
1253   if (process_sp) {
1254     Process::StopLocker stop_locker;
1255     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
1256       std::lock_guard<std::recursive_mutex> guard(
1257           process_sp->GetTarget().GetAPIMutex());
1258       addr = process_sp->AllocateMemory(size, permissions, sb_error.ref());
1259     } else {
1260       sb_error.SetErrorString("process is running");
1261     }
1262   } else {
1263     sb_error.SetErrorString("SBProcess is invalid");
1264   }
1265   return addr;
1266 }
1267
1268 lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
1269   LLDB_INSTRUMENT_VA(this, ptr);
1270
1271   lldb::SBError sb_error;
1272   ProcessSP process_sp(GetSP());
1273   if (process_sp) {
1274     Process::StopLocker stop_locker;
1275     if (stop_locker.TryLock(&process_sp->GetRunLock())) {
1276       std::lock_guard<std::recursive_mutex> guard(
1277           process_sp->GetTarget().GetAPIMutex());
1278       Status error = process_sp->DeallocateMemory(ptr);
1279       sb_error.SetError(error);
1280     } else {
1281       sb_error.SetErrorString("process is running");
1282     }
1283   } else {
1284     sb_error.SetErrorString("SBProcess is invalid");
1285   }
1286   return sb_error;
1287 }
1288
1289 lldb::SBScriptObject SBProcess::GetScriptedImplementation() {
1290   LLDB_INSTRUMENT_VA(this);
1291   ProcessSP process_sp(GetSP());
1292   return lldb::SBScriptObject((process_sp) ? process_sp->GetImplementation()
1293                                            : nullptr,
1294                               eScriptLanguageDefault);
1295 }