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