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