lldb/source/API/SBProcess.cpp

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