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
49using namespace lldb;
50using namespace lldb_private;
51
52SBProcess::SBProcess() : m_opaque_wp() {
53  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess);
54}
55
56// SBProcess constructor
57
58SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
59  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
60}
61
62SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
63    : m_opaque_wp(process_sp) {
64  LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
65}
66
67const 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
77SBProcess::~SBProcess() {}
78
79const char *SBProcess::GetBroadcasterClassName() {
80  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
81                                    GetBroadcasterClassName);
82
83  return Process::GetStaticBroadcasterClass().AsCString();
84}
85
86const 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
96const 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
106lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
107
108void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
109
110void SBProcess::Clear() {
111  LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
112
113  m_opaque_wp.reset();
114}
115
116bool SBProcess::IsValid() const {
117  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
118  return this->operator bool();
119}
120SBProcess::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
127bool 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
168bool 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
192uint32_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
209SBThread 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
226SBThread 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
244SBTarget 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
258size_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
272size_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
286size_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
300size_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
314lldb::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
334void 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
341void 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
348void 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
365void 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
382bool 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
396bool 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
412bool 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
428SBThread 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
447uint32_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
464SBQueue 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
484uint32_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
500SBEvent 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
517StateType 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
531int 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
545const 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
558lldb::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
569uint32_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
579ByteOrder 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
591uint32_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
603SBError 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
623SBError 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
638SBError 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
653SBError 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
668SBError 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
676SBError 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
691SBError 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
706SBUnixSignals 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
715void 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
724SBThread 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
743SBThread 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
763StateType 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
772bool 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
781size_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
788const char *
789SBProcess::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
798SBProcess 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
812bool 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
819lldb::SBStructuredData
820SBProcess::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
828bool 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
836bool 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
846SBBroadcaster 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
859const char *SBProcess::GetBroadcasterClass() {
860  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
861                                    GetBroadcasterClass);
862
863  return Process::GetStaticBroadcasterClass().AsCString();
864}
865
866size_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
893size_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
917uint64_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
941lldb::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
963size_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
988bool 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
1013uint32_t
1014SBProcess::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
1031uint32_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
1040uint32_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
1066uint32_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
1104lldb::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
1126lldb::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
1146uint32_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
1157const 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
1173SBThreadCollection 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
1185bool 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
1206lldb::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
1230lldb::SBError
1231SBProcess::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
1256lldb::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
1274lldb::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
1286namespace lldb_private {
1287namespace repro {
1288
1289template <>
1290void 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}
1423