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