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