blob: 76c1badba64d14b73ab6c0d7dde1e4dcbe1a0dce [file] [log] [blame]
Chris Lattner24943d22010-06-08 16:52:24 +00001//===-- 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
Eli Friedman7a62c8b2010-06-09 07:44:37 +000010#include "lldb/API/SBProcess.h"
Chris Lattner24943d22010-06-08 16:52:24 +000011
12#include "lldb/lldb-defines.h"
13#include "lldb/lldb-types.h"
14
Jim Ingham84cdc152010-06-15 19:49:27 +000015#include "lldb/Interpreter/Args.h"
Greg Clayton1a3083a2010-10-06 03:53:16 +000016#include "lldb/Core/Debugger.h"
Caroline Tice7826c882010-10-26 03:11:13 +000017#include "lldb/Core/Log.h"
Chris Lattner24943d22010-06-08 16:52:24 +000018#include "lldb/Core/State.h"
19#include "lldb/Core/Stream.h"
20#include "lldb/Core/StreamFile.h"
21#include "lldb/Target/Process.h"
Chris Lattner24943d22010-06-08 16:52:24 +000022#include "lldb/Target/RegisterContext.h"
Greg Clayton63094e02010-06-23 01:19:29 +000023#include "lldb/Target/Target.h"
24#include "lldb/Target/Thread.h"
Chris Lattner24943d22010-06-08 16:52:24 +000025
26// Project includes
27
Eli Friedman7a62c8b2010-06-09 07:44:37 +000028#include "lldb/API/SBBroadcaster.h"
29#include "lldb/API/SBDebugger.h"
30#include "lldb/API/SBCommandReturnObject.h"
31#include "lldb/API/SBEvent.h"
32#include "lldb/API/SBThread.h"
Caroline Tice98f930f2010-09-20 05:20:02 +000033#include "lldb/API/SBStream.h"
Eli Friedman7a62c8b2010-06-09 07:44:37 +000034#include "lldb/API/SBStringList.h"
Chris Lattner24943d22010-06-08 16:52:24 +000035
36using namespace lldb;
37using namespace lldb_private;
38
39
40
41SBProcess::SBProcess () :
Greg Clayton63094e02010-06-23 01:19:29 +000042 m_opaque_sp()
Chris Lattner24943d22010-06-08 16:52:24 +000043{
44}
45
46
47//----------------------------------------------------------------------
48// SBProcess constructor
49//----------------------------------------------------------------------
50
51SBProcess::SBProcess (const SBProcess& rhs) :
Greg Clayton63094e02010-06-23 01:19:29 +000052 m_opaque_sp (rhs.m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +000053{
54}
55
56
57SBProcess::SBProcess (const lldb::ProcessSP &process_sp) :
Greg Clayton63094e02010-06-23 01:19:29 +000058 m_opaque_sp (process_sp)
Chris Lattner24943d22010-06-08 16:52:24 +000059{
60}
61
Greg Clayton538eb822010-11-05 23:17:00 +000062const SBProcess&
63SBProcess::operator = (const SBProcess& rhs)
64{
65 if (this != &rhs)
66 m_opaque_sp = rhs.m_opaque_sp;
67 return *this;
68}
69
Chris Lattner24943d22010-06-08 16:52:24 +000070//----------------------------------------------------------------------
71// Destructor
72//----------------------------------------------------------------------
73SBProcess::~SBProcess()
74{
75}
76
77void
78SBProcess::SetProcess (const ProcessSP &process_sp)
79{
Greg Clayton63094e02010-06-23 01:19:29 +000080 m_opaque_sp = process_sp;
Chris Lattner24943d22010-06-08 16:52:24 +000081}
82
83void
84SBProcess::Clear ()
85{
Greg Clayton63094e02010-06-23 01:19:29 +000086 m_opaque_sp.reset();
Chris Lattner24943d22010-06-08 16:52:24 +000087}
88
89
90bool
91SBProcess::IsValid() const
92{
Greg Clayton63094e02010-06-23 01:19:29 +000093 return m_opaque_sp.get() != NULL;
Chris Lattner24943d22010-06-08 16:52:24 +000094}
95
James McIlree38093402011-03-04 00:31:13 +000096bool
97SBProcess::RemoteLaunch (char const **argv,
98 char const **envp,
99 const char *stdin_path,
100 const char *stdout_path,
101 const char *stderr_path,
102 const char *working_directory,
103 uint32_t launch_flags,
104 bool stop_at_entry,
105 lldb::SBError& error)
106{
107 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
108 if (log) {
109 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))...",
110 m_opaque_sp.get(),
111 argv,
112 envp,
113 stdin_path ? stdin_path : "NULL",
114 stdout_path ? stdout_path : "NULL",
115 stderr_path ? stderr_path : "NULL",
116 working_directory ? working_directory : "NULL",
117 launch_flags,
118 stop_at_entry,
119 error.get());
120 }
121
122 if (m_opaque_sp)
123 {
124 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
125 if (m_opaque_sp->GetState() == eStateConnected)
126 {
Greg Clayton36bc5ea2011-11-03 21:22:33 +0000127 if (stop_at_entry)
128 launch_flags |= eLaunchFlagStopAtEntry;
129 ProcessLaunchInfo launch_info (stdin_path,
130 stdout_path,
131 stderr_path,
132 working_directory,
133 launch_flags);
134 Module *exe_module = m_opaque_sp->GetTarget().GetExecutableModulePointer();
135 if (exe_module)
136 launch_info.SetExecutableFile(exe_module->GetFileSpec(), true);
137 if (argv)
138 launch_info.GetArguments().AppendArguments (argv);
139 if (envp)
140 launch_info.GetEnvironmentEntries ().SetArguments (envp);
141 error.SetError (m_opaque_sp->Launch (launch_info));
James McIlree38093402011-03-04 00:31:13 +0000142 }
143 else
144 {
145 error.SetErrorString ("must be in eStateConnected to call RemoteLaunch");
146 }
147 }
148 else
149 {
150 error.SetErrorString ("unable to attach pid");
151 }
152
153 if (log) {
154 SBStream sstr;
155 error.GetDescription (sstr);
Johnny Chen42da4da2011-03-05 01:20:11 +0000156 log->Printf ("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s", m_opaque_sp.get(), error.get(), sstr.GetData());
James McIlree38093402011-03-04 00:31:13 +0000157 }
158
159 return error.Success();
160}
161
162bool
163SBProcess::RemoteAttachToProcessWithID (lldb::pid_t pid, lldb::SBError& error)
164{
165 if (m_opaque_sp)
166 {
167 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
168 if (m_opaque_sp->GetState() == eStateConnected)
169 {
Greg Clayton527154d2011-11-15 03:53:30 +0000170 ProcessAttachInfo attach_info;
171 attach_info.SetProcessID (pid);
172 error.SetError (m_opaque_sp->Attach (attach_info));
James McIlree38093402011-03-04 00:31:13 +0000173 }
174 else
175 {
176 error.SetErrorString ("must be in eStateConnected to call RemoteAttachToProcessWithID");
177 }
178 }
179 else
180 {
181 error.SetErrorString ("unable to attach pid");
182 }
183
184 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
185 if (log) {
186 SBStream sstr;
187 error.GetDescription (sstr);
Greg Claytond9919d32011-12-01 23:28:38 +0000188 log->Printf ("SBProcess(%p)::RemoteAttachToProcessWithID (%llu) => SBError (%p): %s", m_opaque_sp.get(), pid, error.get(), sstr.GetData());
James McIlree38093402011-03-04 00:31:13 +0000189 }
190
191 return error.Success();
192}
193
Chris Lattner24943d22010-06-08 16:52:24 +0000194
195uint32_t
196SBProcess::GetNumThreads ()
197{
Greg Claytone005f2c2010-11-06 01:53:30 +0000198 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000199
Caroline Tice7826c882010-10-26 03:11:13 +0000200 uint32_t num_threads = 0;
Greg Clayton63094e02010-06-23 01:19:29 +0000201 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000202 {
Greg Claytonbdcda462010-12-20 20:49:23 +0000203 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Chris Lattner24943d22010-06-08 16:52:24 +0000204 const bool can_update = true;
Caroline Tice7826c882010-10-26 03:11:13 +0000205 num_threads = m_opaque_sp->GetThreadList().GetSize(can_update);
Chris Lattner24943d22010-06-08 16:52:24 +0000206 }
Caroline Tice7826c882010-10-26 03:11:13 +0000207
208 if (log)
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000209 log->Printf ("SBProcess(%p)::GetNumThreads () => %d", m_opaque_sp.get(), num_threads);
Caroline Tice7826c882010-10-26 03:11:13 +0000210
211 return num_threads;
Chris Lattner24943d22010-06-08 16:52:24 +0000212}
213
214SBThread
Jim Inghamc8332952010-08-26 21:32:51 +0000215SBProcess::GetSelectedThread () const
Chris Lattner24943d22010-06-08 16:52:24 +0000216{
Greg Claytone005f2c2010-11-06 01:53:30 +0000217 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000218
Chris Lattner24943d22010-06-08 16:52:24 +0000219 SBThread sb_thread;
Greg Clayton63094e02010-06-23 01:19:29 +0000220 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000221 {
222 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Jim Inghamc8332952010-08-26 21:32:51 +0000223 sb_thread.SetThread (m_opaque_sp->GetThreadList().GetSelectedThread());
Greg Claytonbdcda462010-12-20 20:49:23 +0000224 }
Caroline Tice7826c882010-10-26 03:11:13 +0000225
226 if (log)
227 {
Greg Claytona66ba462010-10-30 04:51:46 +0000228 log->Printf ("SBProcess(%p)::GetSelectedThread () => SBThread(%p)", m_opaque_sp.get(), sb_thread.get());
Caroline Tice7826c882010-10-26 03:11:13 +0000229 }
230
Chris Lattner24943d22010-06-08 16:52:24 +0000231 return sb_thread;
232}
233
234SBTarget
235SBProcess::GetTarget() const
236{
Greg Claytone005f2c2010-11-06 01:53:30 +0000237 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000238
Chris Lattner24943d22010-06-08 16:52:24 +0000239 SBTarget sb_target;
Greg Clayton63094e02010-06-23 01:19:29 +0000240 if (m_opaque_sp)
Greg Clayton13d24fb2012-01-29 20:56:30 +0000241 sb_target = m_opaque_sp->GetTarget().shared_from_this();
Caroline Tice7826c882010-10-26 03:11:13 +0000242
243 if (log)
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000244 log->Printf ("SBProcess(%p)::GetTarget () => SBTarget(%p)", m_opaque_sp.get(), sb_target.get());
Caroline Tice7826c882010-10-26 03:11:13 +0000245
Chris Lattner24943d22010-06-08 16:52:24 +0000246 return sb_target;
247}
248
249
250size_t
251SBProcess::PutSTDIN (const char *src, size_t src_len)
252{
Greg Claytone005f2c2010-11-06 01:53:30 +0000253 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000254
Caroline Tice7826c882010-10-26 03:11:13 +0000255 size_t ret_val = 0;
Greg Claytonbdcda462010-12-20 20:49:23 +0000256 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000257 {
258 Error error;
Caroline Tice7826c882010-10-26 03:11:13 +0000259 ret_val = m_opaque_sp->PutSTDIN (src, src_len, error);
Chris Lattner24943d22010-06-08 16:52:24 +0000260 }
Caroline Tice7826c882010-10-26 03:11:13 +0000261
262 if (log)
Jason Molenda7e5fa7f2011-09-20 21:44:10 +0000263 log->Printf ("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%d) => %lu",
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000264 m_opaque_sp.get(),
265 src,
266 (uint32_t) src_len,
267 ret_val);
Caroline Tice7826c882010-10-26 03:11:13 +0000268
269 return ret_val;
Chris Lattner24943d22010-06-08 16:52:24 +0000270}
271
272size_t
273SBProcess::GetSTDOUT (char *dst, size_t dst_len) const
274{
Greg Clayton49ce6822010-10-31 03:01:06 +0000275 size_t bytes_read = 0;
Greg Claytonbdcda462010-12-20 20:49:23 +0000276 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000277 {
278 Error error;
Greg Clayton49ce6822010-10-31 03:01:06 +0000279 bytes_read = m_opaque_sp->GetSTDOUT (dst, dst_len, error);
Chris Lattner24943d22010-06-08 16:52:24 +0000280 }
Caroline Tice7826c882010-10-26 03:11:13 +0000281
Greg Claytone005f2c2010-11-06 01:53:30 +0000282 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000283 if (log)
Greg Clayton49ce6822010-10-31 03:01:06 +0000284 log->Printf ("SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%zu) => %zu",
285 m_opaque_sp.get(), (int) bytes_read, dst, dst_len, bytes_read);
Caroline Tice7826c882010-10-26 03:11:13 +0000286
Greg Clayton49ce6822010-10-31 03:01:06 +0000287 return bytes_read;
Chris Lattner24943d22010-06-08 16:52:24 +0000288}
289
290size_t
291SBProcess::GetSTDERR (char *dst, size_t dst_len) const
292{
Greg Clayton49ce6822010-10-31 03:01:06 +0000293 size_t bytes_read = 0;
Greg Claytonbdcda462010-12-20 20:49:23 +0000294 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000295 {
296 Error error;
Greg Clayton49ce6822010-10-31 03:01:06 +0000297 bytes_read = m_opaque_sp->GetSTDERR (dst, dst_len, error);
Chris Lattner24943d22010-06-08 16:52:24 +0000298 }
Caroline Tice7826c882010-10-26 03:11:13 +0000299
Greg Claytone005f2c2010-11-06 01:53:30 +0000300 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000301 if (log)
Greg Clayton49ce6822010-10-31 03:01:06 +0000302 log->Printf ("SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%zu) => %zu",
303 m_opaque_sp.get(), (int) bytes_read, dst, dst_len, bytes_read);
Caroline Tice7826c882010-10-26 03:11:13 +0000304
Greg Clayton49ce6822010-10-31 03:01:06 +0000305 return bytes_read;
Chris Lattner24943d22010-06-08 16:52:24 +0000306}
307
308void
Jim Inghamc8332952010-08-26 21:32:51 +0000309SBProcess::ReportEventState (const SBEvent &event, FILE *out) const
Chris Lattner24943d22010-06-08 16:52:24 +0000310{
311 if (out == NULL)
312 return;
313
Greg Claytonbdcda462010-12-20 20:49:23 +0000314 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000315 {
316 const StateType event_state = SBProcess::GetStateFromEvent (event);
317 char message[1024];
318 int message_len = ::snprintf (message,
319 sizeof (message),
Greg Clayton444e35b2011-10-19 18:09:39 +0000320 "Process %llu %s\n",
Greg Clayton63094e02010-06-23 01:19:29 +0000321 m_opaque_sp->GetID(),
Chris Lattner24943d22010-06-08 16:52:24 +0000322 SBDebugger::StateAsCString (event_state));
323
324 if (message_len > 0)
325 ::fwrite (message, 1, message_len, out);
326 }
327}
328
329void
Jim Inghamc8332952010-08-26 21:32:51 +0000330SBProcess::AppendEventStateReport (const SBEvent &event, SBCommandReturnObject &result)
Chris Lattner24943d22010-06-08 16:52:24 +0000331{
Greg Claytonbdcda462010-12-20 20:49:23 +0000332 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000333 {
334 const StateType event_state = SBProcess::GetStateFromEvent (event);
335 char message[1024];
336 ::snprintf (message,
337 sizeof (message),
Greg Clayton444e35b2011-10-19 18:09:39 +0000338 "Process %llu %s\n",
Greg Clayton63094e02010-06-23 01:19:29 +0000339 m_opaque_sp->GetID(),
Chris Lattner24943d22010-06-08 16:52:24 +0000340 SBDebugger::StateAsCString (event_state));
341
342 result.AppendMessage (message);
343 }
344}
345
346bool
Jim Inghamc8332952010-08-26 21:32:51 +0000347SBProcess::SetSelectedThread (const SBThread &thread)
Chris Lattner24943d22010-06-08 16:52:24 +0000348{
Greg Claytonbdcda462010-12-20 20:49:23 +0000349 if (m_opaque_sp)
350 {
351 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Jim Inghamc8332952010-08-26 21:32:51 +0000352 return m_opaque_sp->GetThreadList().SetSelectedThreadByID (thread.GetThreadID());
Greg Claytonbdcda462010-12-20 20:49:23 +0000353 }
Chris Lattner24943d22010-06-08 16:52:24 +0000354 return false;
355}
356
357bool
Jim Inghamc8332952010-08-26 21:32:51 +0000358SBProcess::SetSelectedThreadByID (uint32_t tid)
Chris Lattner24943d22010-06-08 16:52:24 +0000359{
Greg Claytone005f2c2010-11-06 01:53:30 +0000360 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000361
Caroline Tice7826c882010-10-26 03:11:13 +0000362 bool ret_val = false;
Greg Claytonbdcda462010-12-20 20:49:23 +0000363 if (m_opaque_sp)
364 {
365 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Caroline Tice7826c882010-10-26 03:11:13 +0000366 ret_val = m_opaque_sp->GetThreadList().SetSelectedThreadByID (tid);
Greg Claytonbdcda462010-12-20 20:49:23 +0000367 }
Caroline Tice7826c882010-10-26 03:11:13 +0000368
369 if (log)
Greg Clayton49ce6822010-10-31 03:01:06 +0000370 log->Printf ("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4x) => %s",
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000371 m_opaque_sp.get(), tid, (ret_val ? "true" : "false"));
Caroline Tice7826c882010-10-26 03:11:13 +0000372
373 return ret_val;
Chris Lattner24943d22010-06-08 16:52:24 +0000374}
375
376SBThread
377SBProcess::GetThreadAtIndex (size_t index)
378{
Greg Claytone005f2c2010-11-06 01:53:30 +0000379 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000380
Chris Lattner24943d22010-06-08 16:52:24 +0000381 SBThread thread;
Greg Clayton63094e02010-06-23 01:19:29 +0000382 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000383 {
384 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton63094e02010-06-23 01:19:29 +0000385 thread.SetThread (m_opaque_sp->GetThreadList().GetThreadAtIndex(index));
Greg Claytonbdcda462010-12-20 20:49:23 +0000386 }
Caroline Tice7826c882010-10-26 03:11:13 +0000387
388 if (log)
389 {
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000390 log->Printf ("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)",
Greg Claytona66ba462010-10-30 04:51:46 +0000391 m_opaque_sp.get(), (uint32_t) index, thread.get());
Caroline Tice7826c882010-10-26 03:11:13 +0000392 }
393
Chris Lattner24943d22010-06-08 16:52:24 +0000394 return thread;
395}
396
397StateType
398SBProcess::GetState ()
399{
Caroline Tice7826c882010-10-26 03:11:13 +0000400
Caroline Tice7826c882010-10-26 03:11:13 +0000401 StateType ret_val = eStateInvalid;
Greg Claytonbdcda462010-12-20 20:49:23 +0000402 if (m_opaque_sp)
403 {
404 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Caroline Tice7826c882010-10-26 03:11:13 +0000405 ret_val = m_opaque_sp->GetState();
Greg Claytonbdcda462010-12-20 20:49:23 +0000406 }
Caroline Tice7826c882010-10-26 03:11:13 +0000407
Greg Claytone005f2c2010-11-06 01:53:30 +0000408 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000409 if (log)
Greg Clayton49ce6822010-10-31 03:01:06 +0000410 log->Printf ("SBProcess(%p)::GetState () => %s",
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000411 m_opaque_sp.get(),
Caroline Tice61ba7ec2010-10-26 23:49:36 +0000412 lldb_private::StateAsCString (ret_val));
Caroline Tice7826c882010-10-26 03:11:13 +0000413
414 return ret_val;
Chris Lattner24943d22010-06-08 16:52:24 +0000415}
416
417
418int
419SBProcess::GetExitStatus ()
420{
Greg Claytona66ba462010-10-30 04:51:46 +0000421 int exit_status = 0;
422 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000423 {
424 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Claytona66ba462010-10-30 04:51:46 +0000425 exit_status = m_opaque_sp->GetExitStatus ();
Greg Claytonbdcda462010-12-20 20:49:23 +0000426 }
Greg Claytone005f2c2010-11-06 01:53:30 +0000427 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytona66ba462010-10-30 04:51:46 +0000428 if (log)
429 log->Printf ("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)",
430 m_opaque_sp.get(), exit_status, exit_status);
431
432 return exit_status;
Chris Lattner24943d22010-06-08 16:52:24 +0000433}
434
435const char *
436SBProcess::GetExitDescription ()
437{
Greg Claytona66ba462010-10-30 04:51:46 +0000438 const char *exit_desc = NULL;
Greg Claytonbdcda462010-12-20 20:49:23 +0000439 if (m_opaque_sp)
440 {
441 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Claytona66ba462010-10-30 04:51:46 +0000442 exit_desc = m_opaque_sp->GetExitDescription ();
Greg Claytonbdcda462010-12-20 20:49:23 +0000443 }
Greg Claytone005f2c2010-11-06 01:53:30 +0000444 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytona66ba462010-10-30 04:51:46 +0000445 if (log)
446 log->Printf ("SBProcess(%p)::GetExitDescription () => %s",
447 m_opaque_sp.get(), exit_desc);
448 return exit_desc;
Chris Lattner24943d22010-06-08 16:52:24 +0000449}
450
451lldb::pid_t
452SBProcess::GetProcessID ()
453{
Caroline Tice7826c882010-10-26 03:11:13 +0000454 lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
Greg Clayton63094e02010-06-23 01:19:29 +0000455 if (m_opaque_sp)
Caroline Tice7826c882010-10-26 03:11:13 +0000456 ret_val = m_opaque_sp->GetID();
457
Greg Claytone005f2c2010-11-06 01:53:30 +0000458 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000459 if (log)
Greg Claytond9919d32011-12-01 23:28:38 +0000460 log->Printf ("SBProcess(%p)::GetProcessID () => %llu", m_opaque_sp.get(), ret_val);
Caroline Tice7826c882010-10-26 03:11:13 +0000461
462 return ret_val;
Chris Lattner24943d22010-06-08 16:52:24 +0000463}
464
Johnny Chen60a544f2011-03-01 22:56:31 +0000465ByteOrder
466SBProcess::GetByteOrder () const
467{
468 ByteOrder byteOrder = eByteOrderInvalid;
469 if (m_opaque_sp)
470 byteOrder = m_opaque_sp->GetTarget().GetArchitecture().GetByteOrder();
471
472 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
473 if (log)
474 log->Printf ("SBProcess(%p)::GetByteOrder () => %d", m_opaque_sp.get(), byteOrder);
475
476 return byteOrder;
477}
478
Chris Lattner24943d22010-06-08 16:52:24 +0000479uint32_t
480SBProcess::GetAddressByteSize () const
481{
Caroline Tice7826c882010-10-26 03:11:13 +0000482 uint32_t size = 0;
Greg Clayton63094e02010-06-23 01:19:29 +0000483 if (m_opaque_sp)
Greg Clayton395fc332011-02-15 21:59:32 +0000484 size = m_opaque_sp->GetTarget().GetArchitecture().GetAddressByteSize();
Caroline Tice7826c882010-10-26 03:11:13 +0000485
Greg Claytone005f2c2010-11-06 01:53:30 +0000486 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000487 if (log)
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000488 log->Printf ("SBProcess(%p)::GetAddressByteSize () => %d", m_opaque_sp.get(), size);
Caroline Tice7826c882010-10-26 03:11:13 +0000489
490 return size;
Chris Lattner24943d22010-06-08 16:52:24 +0000491}
492
Chris Lattner24943d22010-06-08 16:52:24 +0000493SBError
494SBProcess::Continue ()
495{
Greg Claytone005f2c2010-11-06 01:53:30 +0000496 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytona66ba462010-10-30 04:51:46 +0000497 if (log)
498 log->Printf ("SBProcess(%p)::Continue ()...", m_opaque_sp.get());
Caroline Tice7826c882010-10-26 03:11:13 +0000499
Chris Lattner24943d22010-06-08 16:52:24 +0000500 SBError sb_error;
Greg Claytonde1dd812011-06-24 03:21:43 +0000501 if (m_opaque_sp)
Greg Clayton1a3083a2010-10-06 03:53:16 +0000502 {
Greg Claytonde1dd812011-06-24 03:21:43 +0000503 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
504
Greg Clayton1a3083a2010-10-06 03:53:16 +0000505 Error error (m_opaque_sp->Resume());
506 if (error.Success())
507 {
508 if (m_opaque_sp->GetTarget().GetDebugger().GetAsyncExecution () == false)
Greg Claytona66ba462010-10-30 04:51:46 +0000509 {
510 if (log)
511 log->Printf ("SBProcess(%p)::Continue () waiting for process to stop...", m_opaque_sp.get());
Greg Clayton1a3083a2010-10-06 03:53:16 +0000512 m_opaque_sp->WaitForProcessToStop (NULL);
Greg Claytona66ba462010-10-30 04:51:46 +0000513 }
Greg Clayton1a3083a2010-10-06 03:53:16 +0000514 }
515 sb_error.SetError(error);
516 }
Chris Lattner24943d22010-06-08 16:52:24 +0000517 else
518 sb_error.SetErrorString ("SBProcess is invalid");
519
Caroline Tice7826c882010-10-26 03:11:13 +0000520 if (log)
521 {
522 SBStream sstr;
523 sb_error.GetDescription (sstr);
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000524 log->Printf ("SBProcess(%p)::Continue () => SBError (%p): %s", m_opaque_sp.get(), sb_error.get(), sstr.GetData());
Caroline Tice7826c882010-10-26 03:11:13 +0000525 }
526
Chris Lattner24943d22010-06-08 16:52:24 +0000527 return sb_error;
528}
529
530
531SBError
532SBProcess::Destroy ()
533{
534 SBError sb_error;
Greg Clayton63094e02010-06-23 01:19:29 +0000535 if (m_opaque_sp)
Greg Clayton72e1c782011-01-22 23:43:18 +0000536 {
537 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton63094e02010-06-23 01:19:29 +0000538 sb_error.SetError(m_opaque_sp->Destroy());
Greg Clayton72e1c782011-01-22 23:43:18 +0000539 }
Chris Lattner24943d22010-06-08 16:52:24 +0000540 else
541 sb_error.SetErrorString ("SBProcess is invalid");
542
Greg Claytone005f2c2010-11-06 01:53:30 +0000543 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytona66ba462010-10-30 04:51:46 +0000544 if (log)
545 {
546 SBStream sstr;
547 sb_error.GetDescription (sstr);
Greg Clayton72e1c782011-01-22 23:43:18 +0000548 log->Printf ("SBProcess(%p)::Destroy () => SBError (%p): %s",
549 m_opaque_sp.get(),
550 sb_error.get(),
551 sstr.GetData());
Greg Claytona66ba462010-10-30 04:51:46 +0000552 }
553
Chris Lattner24943d22010-06-08 16:52:24 +0000554 return sb_error;
555}
556
557
558SBError
559SBProcess::Stop ()
560{
561 SBError sb_error;
Greg Claytonde1dd812011-06-24 03:21:43 +0000562 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000563 {
564 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton63094e02010-06-23 01:19:29 +0000565 sb_error.SetError (m_opaque_sp->Halt());
Greg Claytonbdcda462010-12-20 20:49:23 +0000566 }
Chris Lattner24943d22010-06-08 16:52:24 +0000567 else
568 sb_error.SetErrorString ("SBProcess is invalid");
Caroline Tice7826c882010-10-26 03:11:13 +0000569
Greg Claytone005f2c2010-11-06 01:53:30 +0000570 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000571 if (log)
572 {
573 SBStream sstr;
574 sb_error.GetDescription (sstr);
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000575 log->Printf ("SBProcess(%p)::Stop () => SBError (%p): %s",
576 m_opaque_sp.get(),
577 sb_error.get(),
Caroline Tice61ba7ec2010-10-26 23:49:36 +0000578 sstr.GetData());
Caroline Tice7826c882010-10-26 03:11:13 +0000579 }
580
Chris Lattner24943d22010-06-08 16:52:24 +0000581 return sb_error;
582}
583
584SBError
585SBProcess::Kill ()
586{
587 SBError sb_error;
Greg Clayton63094e02010-06-23 01:19:29 +0000588 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000589 {
590 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton63094e02010-06-23 01:19:29 +0000591 sb_error.SetError (m_opaque_sp->Destroy());
Greg Claytonbdcda462010-12-20 20:49:23 +0000592 }
Chris Lattner24943d22010-06-08 16:52:24 +0000593 else
594 sb_error.SetErrorString ("SBProcess is invalid");
Caroline Tice7826c882010-10-26 03:11:13 +0000595
Greg Claytone005f2c2010-11-06 01:53:30 +0000596 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000597 if (log)
598 {
599 SBStream sstr;
600 sb_error.GetDescription (sstr);
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000601 log->Printf ("SBProcess(%p)::Kill () => SBError (%p): %s",
602 m_opaque_sp.get(),
603 sb_error.get(),
Caroline Tice61ba7ec2010-10-26 23:49:36 +0000604 sstr.GetData());
Caroline Tice7826c882010-10-26 03:11:13 +0000605 }
606
Chris Lattner24943d22010-06-08 16:52:24 +0000607 return sb_error;
608}
609
Chris Lattner24943d22010-06-08 16:52:24 +0000610SBError
611SBProcess::Detach ()
612{
613 SBError sb_error;
Greg Clayton63094e02010-06-23 01:19:29 +0000614 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000615 {
616 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton63094e02010-06-23 01:19:29 +0000617 sb_error.SetError (m_opaque_sp->Detach());
Greg Claytonbdcda462010-12-20 20:49:23 +0000618 }
Chris Lattner24943d22010-06-08 16:52:24 +0000619 else
620 sb_error.SetErrorString ("SBProcess is invalid");
621
622 return sb_error;
623}
624
625SBError
Greg Claytona66ba462010-10-30 04:51:46 +0000626SBProcess::Signal (int signo)
Chris Lattner24943d22010-06-08 16:52:24 +0000627{
628 SBError sb_error;
Greg Clayton63094e02010-06-23 01:19:29 +0000629 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000630 {
631 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Claytona66ba462010-10-30 04:51:46 +0000632 sb_error.SetError (m_opaque_sp->Signal (signo));
Greg Claytonbdcda462010-12-20 20:49:23 +0000633 }
Chris Lattner24943d22010-06-08 16:52:24 +0000634 else
635 sb_error.SetErrorString ("SBProcess is invalid");
Greg Claytone005f2c2010-11-06 01:53:30 +0000636 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytona66ba462010-10-30 04:51:46 +0000637 if (log)
638 {
639 SBStream sstr;
640 sb_error.GetDescription (sstr);
641 log->Printf ("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s",
642 m_opaque_sp.get(),
643 signo,
644 sb_error.get(),
645 sstr.GetData());
646 }
Chris Lattner24943d22010-06-08 16:52:24 +0000647 return sb_error;
648}
649
Chris Lattner24943d22010-06-08 16:52:24 +0000650SBThread
Greg Claytona66ba462010-10-30 04:51:46 +0000651SBProcess::GetThreadByID (tid_t tid)
Chris Lattner24943d22010-06-08 16:52:24 +0000652{
Greg Claytona66ba462010-10-30 04:51:46 +0000653 SBThread sb_thread;
Greg Clayton63094e02010-06-23 01:19:29 +0000654 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000655 {
656 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Claytona66ba462010-10-30 04:51:46 +0000657 sb_thread.SetThread (m_opaque_sp->GetThreadList().FindThreadByID ((tid_t) tid));
Greg Claytonbdcda462010-12-20 20:49:23 +0000658 }
Greg Claytona66ba462010-10-30 04:51:46 +0000659
Greg Claytone005f2c2010-11-06 01:53:30 +0000660 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytona66ba462010-10-30 04:51:46 +0000661 if (log)
662 {
Greg Claytond9919d32011-12-01 23:28:38 +0000663 log->Printf ("SBProcess(%p)::GetThreadByID (tid=0x%4.4llx) => SBThread (%p)",
Greg Claytona66ba462010-10-30 04:51:46 +0000664 m_opaque_sp.get(),
665 tid,
666 sb_thread.get());
667 }
668
669 return sb_thread;
Chris Lattner24943d22010-06-08 16:52:24 +0000670}
671
Chris Lattner24943d22010-06-08 16:52:24 +0000672StateType
673SBProcess::GetStateFromEvent (const SBEvent &event)
674{
Greg Claytone005f2c2010-11-06 01:53:30 +0000675 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000676
Caroline Tice7826c882010-10-26 03:11:13 +0000677 StateType ret_val = Process::ProcessEventData::GetStateFromEvent (event.get());
678
679 if (log)
Greg Clayton49ce6822010-10-31 03:01:06 +0000680 log->Printf ("SBProcess::GetStateFromEvent (event.sp=%p) => %s", event.get(),
Caroline Tice61ba7ec2010-10-26 23:49:36 +0000681 lldb_private::StateAsCString (ret_val));
Caroline Tice7826c882010-10-26 03:11:13 +0000682
683 return ret_val;
Chris Lattner24943d22010-06-08 16:52:24 +0000684}
685
Chris Lattner24943d22010-06-08 16:52:24 +0000686bool
687SBProcess::GetRestartedFromEvent (const SBEvent &event)
688{
Greg Clayton63094e02010-06-23 01:19:29 +0000689 return Process::ProcessEventData::GetRestartedFromEvent (event.get());
Chris Lattner24943d22010-06-08 16:52:24 +0000690}
691
692SBProcess
693SBProcess::GetProcessFromEvent (const SBEvent &event)
694{
Greg Clayton63094e02010-06-23 01:19:29 +0000695 SBProcess process(Process::ProcessEventData::GetProcessFromEvent (event.get()));
Chris Lattner24943d22010-06-08 16:52:24 +0000696 return process;
697}
698
699
700SBBroadcaster
701SBProcess::GetBroadcaster () const
702{
Greg Claytone005f2c2010-11-06 01:53:30 +0000703 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000704
Greg Clayton63094e02010-06-23 01:19:29 +0000705 SBBroadcaster broadcaster(m_opaque_sp.get(), false);
Caroline Tice7826c882010-10-26 03:11:13 +0000706
707 if (log)
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000708 log->Printf ("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", m_opaque_sp.get(),
Caroline Tice61ba7ec2010-10-26 23:49:36 +0000709 broadcaster.get());
Caroline Tice7826c882010-10-26 03:11:13 +0000710
Chris Lattner24943d22010-06-08 16:52:24 +0000711 return broadcaster;
712}
713
714lldb_private::Process *
715SBProcess::operator->() const
716{
Greg Clayton63094e02010-06-23 01:19:29 +0000717 return m_opaque_sp.get();
Chris Lattner24943d22010-06-08 16:52:24 +0000718}
719
720size_t
721SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error)
722{
Greg Claytone005f2c2010-11-06 01:53:30 +0000723 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Tice7826c882010-10-26 03:11:13 +0000724
Chris Lattner24943d22010-06-08 16:52:24 +0000725 size_t bytes_read = 0;
726
Greg Claytona66ba462010-10-30 04:51:46 +0000727 if (log)
728 {
729 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p))...",
730 m_opaque_sp.get(),
731 addr,
732 dst,
Greg Claytonbae39c52011-12-03 00:46:21 +0000733 dst_len,
Greg Claytona66ba462010-10-30 04:51:46 +0000734 sb_error.get());
735 }
736
Greg Claytonbdcda462010-12-20 20:49:23 +0000737 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000738 {
739 Error error;
Greg Claytonbdcda462010-12-20 20:49:23 +0000740 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton63094e02010-06-23 01:19:29 +0000741 bytes_read = m_opaque_sp->ReadMemory (addr, dst, dst_len, error);
Chris Lattner24943d22010-06-08 16:52:24 +0000742 sb_error.SetError (error);
743 }
744 else
745 {
746 sb_error.SetErrorString ("SBProcess is invalid");
747 }
748
Caroline Tice7826c882010-10-26 03:11:13 +0000749 if (log)
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000750 {
751 SBStream sstr;
752 sb_error.GetDescription (sstr);
Greg Claytonbae39c52011-12-03 00:46:21 +0000753 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p): %s) => %zu",
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000754 m_opaque_sp.get(),
755 addr,
756 dst,
Greg Claytonbae39c52011-12-03 00:46:21 +0000757 dst_len,
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000758 sb_error.get(),
759 sstr.GetData(),
Greg Claytonbae39c52011-12-03 00:46:21 +0000760 bytes_read);
Greg Clayton3f5ee7f2010-10-29 04:59:35 +0000761 }
Caroline Tice7826c882010-10-26 03:11:13 +0000762
Chris Lattner24943d22010-06-08 16:52:24 +0000763 return bytes_read;
764}
765
766size_t
Greg Clayton4a2e3372011-12-15 03:14:23 +0000767SBProcess::ReadCStringFromMemory (addr_t addr, void *buf, size_t size, lldb::SBError &sb_error)
768{
769 size_t bytes_read = 0;
770 if (m_opaque_sp)
771 {
772 Error error;
773 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
774 bytes_read = m_opaque_sp->ReadCStringFromMemory (addr, (char *)buf, size, error);
775 sb_error.SetError (error);
776 }
777 else
778 {
779 sb_error.SetErrorString ("SBProcess is invalid");
780 }
781 return bytes_read;
782}
783
784uint64_t
785SBProcess::ReadUnsignedFromMemory (addr_t addr, uint32_t byte_size, lldb::SBError &sb_error)
786{
787 if (m_opaque_sp)
788 {
789 Error error;
790 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
791 uint64_t value = m_opaque_sp->ReadUnsignedIntegerFromMemory (addr, byte_size, 0, error);
792 sb_error.SetError (error);
793 return value;
794 }
795 else
796 {
797 sb_error.SetErrorString ("SBProcess is invalid");
798 }
799 return 0;
800}
801
802lldb::addr_t
803SBProcess::ReadPointerFromMemory (addr_t addr, lldb::SBError &sb_error)
804{
805 lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
806 if (m_opaque_sp)
807 {
808 Error error;
809 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
810 ptr = m_opaque_sp->ReadPointerFromMemory (addr, error);
811 sb_error.SetError (error);
812 }
813 else
814 {
815 sb_error.SetErrorString ("SBProcess is invalid");
816 }
817 return ptr;
818}
819
820size_t
Chris Lattner24943d22010-06-08 16:52:24 +0000821SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error)
822{
823 size_t bytes_written = 0;
824
Greg Claytone005f2c2010-11-06 01:53:30 +0000825 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytona66ba462010-10-30 04:51:46 +0000826 if (log)
827 {
828 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p))...",
829 m_opaque_sp.get(),
830 addr,
831 src,
Greg Claytonbae39c52011-12-03 00:46:21 +0000832 src_len,
Greg Claytona66ba462010-10-30 04:51:46 +0000833 sb_error.get());
834 }
835
Greg Claytonbdcda462010-12-20 20:49:23 +0000836 if (m_opaque_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000837 {
838 Error error;
Greg Claytonbdcda462010-12-20 20:49:23 +0000839 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton63094e02010-06-23 01:19:29 +0000840 bytes_written = m_opaque_sp->WriteMemory (addr, src, src_len, error);
Chris Lattner24943d22010-06-08 16:52:24 +0000841 sb_error.SetError (error);
842 }
843
Greg Claytona66ba462010-10-30 04:51:46 +0000844 if (log)
845 {
846 SBStream sstr;
847 sb_error.GetDescription (sstr);
Greg Claytonbae39c52011-12-03 00:46:21 +0000848 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p): %s) => %zu",
Greg Claytona66ba462010-10-30 04:51:46 +0000849 m_opaque_sp.get(),
850 addr,
851 src,
Greg Claytonbae39c52011-12-03 00:46:21 +0000852 src_len,
Greg Claytona66ba462010-10-30 04:51:46 +0000853 sb_error.get(),
854 sstr.GetData(),
Greg Claytonbae39c52011-12-03 00:46:21 +0000855 bytes_written);
Greg Claytona66ba462010-10-30 04:51:46 +0000856 }
857
Chris Lattner24943d22010-06-08 16:52:24 +0000858 return bytes_written;
859}
860
861// Mimic shared pointer...
862lldb_private::Process *
863SBProcess::get() const
864{
Greg Clayton63094e02010-06-23 01:19:29 +0000865 return m_opaque_sp.get();
Chris Lattner24943d22010-06-08 16:52:24 +0000866}
867
Caroline Tice98f930f2010-09-20 05:20:02 +0000868bool
869SBProcess::GetDescription (SBStream &description)
870{
Greg Clayton96154be2011-11-13 06:57:31 +0000871 Stream &strm = description.ref();
872
Caroline Tice98f930f2010-09-20 05:20:02 +0000873 if (m_opaque_sp)
874 {
875 char path[PATH_MAX];
876 GetTarget().GetExecutable().GetPath (path, sizeof(path));
Greg Clayton5beb99d2011-08-11 02:48:45 +0000877 Module *exe_module = m_opaque_sp->GetTarget().GetExecutableModulePointer();
Greg Clayton5c4c7462010-10-06 03:09:58 +0000878 const char *exe_name = NULL;
879 if (exe_module)
880 exe_name = exe_module->GetFileSpec().GetFilename().AsCString();
881
Greg Clayton96154be2011-11-13 06:57:31 +0000882 strm.Printf ("SBProcess: pid = %llu, state = %s, threads = %d%s%s",
883 m_opaque_sp->GetID(),
884 lldb_private::StateAsCString (GetState()),
885 GetNumThreads(),
886 exe_name ? ", executable = " : "",
887 exe_name ? exe_name : "");
Caroline Tice98f930f2010-09-20 05:20:02 +0000888 }
889 else
Greg Clayton96154be2011-11-13 06:57:31 +0000890 strm.PutCString ("No value");
Caroline Tice98f930f2010-09-20 05:20:02 +0000891
892 return true;
893}
Greg Clayton0baa3942010-11-04 01:54:29 +0000894
895uint32_t
896SBProcess::LoadImage (lldb::SBFileSpec &sb_image_spec, lldb::SBError &sb_error)
897{
898 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000899 {
900 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton0e0fd1c2010-12-05 20:38:01 +0000901 return m_opaque_sp->LoadImage (*sb_image_spec, sb_error.ref());
Greg Claytonbdcda462010-12-20 20:49:23 +0000902 }
Greg Clayton0baa3942010-11-04 01:54:29 +0000903 return LLDB_INVALID_IMAGE_TOKEN;
904}
905
906lldb::SBError
907SBProcess::UnloadImage (uint32_t image_token)
908{
909 lldb::SBError sb_error;
910 if (m_opaque_sp)
Greg Claytonbdcda462010-12-20 20:49:23 +0000911 {
912 Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
Greg Clayton0baa3942010-11-04 01:54:29 +0000913 sb_error.SetError (m_opaque_sp->UnloadImage (image_token));
Greg Claytonbdcda462010-12-20 20:49:23 +0000914 }
Greg Clayton0baa3942010-11-04 01:54:29 +0000915 else
916 sb_error.SetErrorString("invalid process");
917 return sb_error;
918}