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