blob: ecf0a647ef4fc668ea01c4187434581747910baf [file] [log] [blame]
Chris Lattner30fdc8d2010-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 Friedman4c5de692010-06-09 07:44:37 +000010#include "lldb/API/SBProcess.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000011
Virgile Bellobdae3782013-08-28 12:14:27 +000012// C Includes
13#include <inttypes.h>
14
Chris Lattner30fdc8d2010-06-08 16:52:24 +000015#include "lldb/lldb-defines.h"
16#include "lldb/lldb-types.h"
17
Jim Ingham40af72e2010-06-15 19:49:27 +000018#include "lldb/Interpreter/Args.h"
Greg Clayton5d5028b2010-10-06 03:53:16 +000019#include "lldb/Core/Debugger.h"
Caroline Ticeceb6b132010-10-26 03:11:13 +000020#include "lldb/Core/Log.h"
Greg Clayton1f746072012-08-29 21:13:06 +000021#include "lldb/Core/Module.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000022#include "lldb/Core/State.h"
23#include "lldb/Core/Stream.h"
24#include "lldb/Core/StreamFile.h"
25#include "lldb/Target/Process.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000026#include "lldb/Target/RegisterContext.h"
Jason Molenda8c713372013-11-05 11:00:35 +000027#include "lldb/Target/SystemRuntime.h"
Greg Clayton66111032010-06-23 01:19:29 +000028#include "lldb/Target/Target.h"
29#include "lldb/Target/Thread.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000030
31// Project includes
32
Eli Friedman4c5de692010-06-09 07:44:37 +000033#include "lldb/API/SBBroadcaster.h"
Eli Friedman4c5de692010-06-09 07:44:37 +000034#include "lldb/API/SBCommandReturnObject.h"
Greg Clayton0e615682012-02-24 05:03:03 +000035#include "lldb/API/SBDebugger.h"
Eli Friedman4c5de692010-06-09 07:44:37 +000036#include "lldb/API/SBEvent.h"
Greg Clayton0e615682012-02-24 05:03:03 +000037#include "lldb/API/SBFileSpec.h"
Eli Friedman4c5de692010-06-09 07:44:37 +000038#include "lldb/API/SBThread.h"
Kuba Breckaa51ea382014-09-06 01:33:13 +000039#include "lldb/API/SBThreadCollection.h"
Caroline Ticedde9cff2010-09-20 05:20:02 +000040#include "lldb/API/SBStream.h"
Eli Friedman4c5de692010-06-09 07:44:37 +000041#include "lldb/API/SBStringList.h"
Todd Fiala802dc4022014-06-23 19:30:49 +000042#include "lldb/API/SBUnixSignals.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000043
44using namespace lldb;
45using namespace lldb_private;
46
47
Chris Lattner30fdc8d2010-06-08 16:52:24 +000048SBProcess::SBProcess () :
Greg Clayton4e0fe8a2012-07-12 20:32:19 +000049 m_opaque_wp()
Chris Lattner30fdc8d2010-06-08 16:52:24 +000050{
51}
52
53
54//----------------------------------------------------------------------
55// SBProcess constructor
56//----------------------------------------------------------------------
57
58SBProcess::SBProcess (const SBProcess& rhs) :
Greg Clayton4e0fe8a2012-07-12 20:32:19 +000059 m_opaque_wp (rhs.m_opaque_wp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +000060{
61}
62
63
64SBProcess::SBProcess (const lldb::ProcessSP &process_sp) :
Greg Clayton4e0fe8a2012-07-12 20:32:19 +000065 m_opaque_wp (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +000066{
67}
68
Greg Claytonefabb122010-11-05 23:17:00 +000069const SBProcess&
70SBProcess::operator = (const SBProcess& rhs)
71{
72 if (this != &rhs)
Greg Clayton4e0fe8a2012-07-12 20:32:19 +000073 m_opaque_wp = rhs.m_opaque_wp;
Greg Claytonefabb122010-11-05 23:17:00 +000074 return *this;
75}
76
Chris Lattner30fdc8d2010-06-08 16:52:24 +000077//----------------------------------------------------------------------
78// Destructor
79//----------------------------------------------------------------------
80SBProcess::~SBProcess()
81{
82}
83
Jim Ingham4bddaeb2012-02-16 06:50:00 +000084const char *
85SBProcess::GetBroadcasterClassName ()
86{
87 return Process::GetStaticBroadcasterClass().AsCString();
88}
89
Jim Inghamd7b30ef2012-10-26 19:18:04 +000090const char *
91SBProcess::GetPluginName ()
92{
93 ProcessSP process_sp(GetSP());
94 if (process_sp)
95 {
Greg Clayton57abc5d2013-05-10 21:47:16 +000096 return process_sp->GetPluginName().GetCString();
Jim Inghamd7b30ef2012-10-26 19:18:04 +000097 }
98 return "<Unknown>";
99}
100
101const char *
102SBProcess::GetShortPluginName ()
103{
104 ProcessSP process_sp(GetSP());
105 if (process_sp)
106 {
Greg Clayton57abc5d2013-05-10 21:47:16 +0000107 return process_sp->GetPluginName().GetCString();
Jim Inghamd7b30ef2012-10-26 19:18:04 +0000108 }
109 return "<Unknown>";
110}
111
112
Greg Claytonb9556ac2012-01-30 07:41:31 +0000113lldb::ProcessSP
114SBProcess::GetSP() const
115{
Greg Clayton4e0fe8a2012-07-12 20:32:19 +0000116 return m_opaque_wp.lock();
Greg Claytonb9556ac2012-01-30 07:41:31 +0000117}
118
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000119void
Greg Claytonb9556ac2012-01-30 07:41:31 +0000120SBProcess::SetSP (const ProcessSP &process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000121{
Greg Clayton4e0fe8a2012-07-12 20:32:19 +0000122 m_opaque_wp = process_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000123}
124
125void
126SBProcess::Clear ()
127{
Greg Clayton4e0fe8a2012-07-12 20:32:19 +0000128 m_opaque_wp.reset();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000129}
130
131
132bool
133SBProcess::IsValid() const
134{
Jim Ingham4fc6cb92012-08-22 21:34:33 +0000135 ProcessSP process_sp(m_opaque_wp.lock());
136 return ((bool) process_sp && process_sp->IsValid());
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000137}
138
James McIlree9631aae2011-03-04 00:31:13 +0000139bool
140SBProcess::RemoteLaunch (char const **argv,
141 char const **envp,
142 const char *stdin_path,
143 const char *stdout_path,
144 const char *stderr_path,
145 const char *working_directory,
146 uint32_t launch_flags,
147 bool stop_at_entry,
148 lldb::SBError& error)
149{
Greg Clayton5160ce52013-03-27 23:08:40 +0000150 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000151 if (log)
James McIlree9631aae2011-03-04 00:31:13 +0000152 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))...",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000153 static_cast<void*>(m_opaque_wp.lock().get()),
154 static_cast<void*>(argv), static_cast<void*>(envp),
155 stdin_path ? stdin_path : "NULL",
156 stdout_path ? stdout_path : "NULL",
157 stderr_path ? stderr_path : "NULL",
James McIlree9631aae2011-03-04 00:31:13 +0000158 working_directory ? working_directory : "NULL",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000159 launch_flags, stop_at_entry,
160 static_cast<void*>(error.get()));
161
Greg Claytonacdbe812012-01-30 09:04:36 +0000162 ProcessSP process_sp(GetSP());
163 if (process_sp)
James McIlree9631aae2011-03-04 00:31:13 +0000164 {
Greg Claytonc9858e42012-04-06 02:17:47 +0000165 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
166 if (process_sp->GetState() == eStateConnected)
James McIlree9631aae2011-03-04 00:31:13 +0000167 {
Greg Claytonc9858e42012-04-06 02:17:47 +0000168 if (stop_at_entry)
169 launch_flags |= eLaunchFlagStopAtEntry;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000170 ProcessLaunchInfo launch_info (stdin_path,
Greg Claytonc9858e42012-04-06 02:17:47 +0000171 stdout_path,
172 stderr_path,
173 working_directory,
174 launch_flags);
175 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
176 if (exe_module)
Greg Clayton14715c62013-06-29 00:10:32 +0000177 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
Greg Claytonc9858e42012-04-06 02:17:47 +0000178 if (argv)
179 launch_info.GetArguments().AppendArguments (argv);
180 if (envp)
181 launch_info.GetEnvironmentEntries ().SetArguments (envp);
182 error.SetError (process_sp->Launch (launch_info));
James McIlree9631aae2011-03-04 00:31:13 +0000183 }
184 else
185 {
Greg Claytonc9858e42012-04-06 02:17:47 +0000186 error.SetErrorString ("must be in eStateConnected to call RemoteLaunch");
James McIlree9631aae2011-03-04 00:31:13 +0000187 }
188 }
189 else
190 {
191 error.SetErrorString ("unable to attach pid");
192 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000193
James McIlree9631aae2011-03-04 00:31:13 +0000194 if (log) {
195 SBStream sstr;
196 error.GetDescription (sstr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000197 log->Printf ("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s",
198 static_cast<void*>(process_sp.get()),
199 static_cast<void*>(error.get()), sstr.GetData());
James McIlree9631aae2011-03-04 00:31:13 +0000200 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000201
James McIlree9631aae2011-03-04 00:31:13 +0000202 return error.Success();
203}
204
205bool
206SBProcess::RemoteAttachToProcessWithID (lldb::pid_t pid, lldb::SBError& error)
207{
Greg Claytonacdbe812012-01-30 09:04:36 +0000208 ProcessSP process_sp(GetSP());
209 if (process_sp)
James McIlree9631aae2011-03-04 00:31:13 +0000210 {
Greg Claytonc9858e42012-04-06 02:17:47 +0000211 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
212 if (process_sp->GetState() == eStateConnected)
James McIlree9631aae2011-03-04 00:31:13 +0000213 {
Greg Claytonc9858e42012-04-06 02:17:47 +0000214 ProcessAttachInfo attach_info;
215 attach_info.SetProcessID (pid);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000216 error.SetError (process_sp->Attach (attach_info));
James McIlree9631aae2011-03-04 00:31:13 +0000217 }
218 else
219 {
Greg Claytonc9858e42012-04-06 02:17:47 +0000220 error.SetErrorString ("must be in eStateConnected to call RemoteAttachToProcessWithID");
James McIlree9631aae2011-03-04 00:31:13 +0000221 }
222 }
223 else
224 {
225 error.SetErrorString ("unable to attach pid");
226 }
227
Greg Clayton5160ce52013-03-27 23:08:40 +0000228 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
James McIlree9631aae2011-03-04 00:31:13 +0000229 if (log) {
230 SBStream sstr;
231 error.GetDescription (sstr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000232 log->Printf ("SBProcess(%p)::RemoteAttachToProcessWithID (%" PRIu64 ") => SBError (%p): %s",
233 static_cast<void*>(process_sp.get()), pid,
234 static_cast<void*>(error.get()), sstr.GetData());
James McIlree9631aae2011-03-04 00:31:13 +0000235 }
236
237 return error.Success();
238}
239
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000240
241uint32_t
242SBProcess::GetNumThreads ()
243{
Greg Clayton5160ce52013-03-27 23:08:40 +0000244 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000245
Caroline Ticeceb6b132010-10-26 03:11:13 +0000246 uint32_t num_threads = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +0000247 ProcessSP process_sp(GetSP());
248 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000249 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +0000250 Process::StopLocker stop_locker;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000251
Greg Clayton7fdf9ef2012-04-05 16:12:35 +0000252 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
Greg Claytonacdbe812012-01-30 09:04:36 +0000253 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Greg Claytonacdbe812012-01-30 09:04:36 +0000254 num_threads = process_sp->GetThreadList().GetSize(can_update);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000255 }
Caroline Ticeceb6b132010-10-26 03:11:13 +0000256
257 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000258 log->Printf ("SBProcess(%p)::GetNumThreads () => %d",
259 static_cast<void*>(process_sp.get()), num_threads);
Caroline Ticeceb6b132010-10-26 03:11:13 +0000260
261 return num_threads;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000262}
263
264SBThread
Jim Ingham2976d002010-08-26 21:32:51 +0000265SBProcess::GetSelectedThread () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000266{
Greg Clayton5160ce52013-03-27 23:08:40 +0000267 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000268
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000269 SBThread sb_thread;
Greg Clayton17a6ad02012-01-30 02:53:15 +0000270 ThreadSP thread_sp;
Greg Claytonacdbe812012-01-30 09:04:36 +0000271 ProcessSP process_sp(GetSP());
272 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000273 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000274 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
275 thread_sp = process_sp->GetThreadList().GetSelectedThread();
Greg Clayton17a6ad02012-01-30 02:53:15 +0000276 sb_thread.SetThread (thread_sp);
Greg Claytonaf67cec2010-12-20 20:49:23 +0000277 }
Caroline Ticeceb6b132010-10-26 03:11:13 +0000278
279 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000280 log->Printf ("SBProcess(%p)::GetSelectedThread () => SBThread(%p)",
281 static_cast<void*>(process_sp.get()),
282 static_cast<void*>(thread_sp.get()));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000283
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000284 return sb_thread;
285}
286
Greg Claytona4d87472013-01-18 23:41:08 +0000287SBThread
288SBProcess::CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context)
289{
Greg Clayton5160ce52013-03-27 23:08:40 +0000290 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000291
Greg Claytona4d87472013-01-18 23:41:08 +0000292 SBThread sb_thread;
293 ThreadSP thread_sp;
294 ProcessSP process_sp(GetSP());
295 if (process_sp)
296 {
297 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
298 thread_sp = process_sp->CreateOSPluginThread(tid, context);
299 sb_thread.SetThread (thread_sp);
300 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000301
Greg Claytona4d87472013-01-18 23:41:08 +0000302 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000303 log->Printf ("SBProcess(%p)::CreateOSPluginThread (tid=0x%" PRIx64 ", context=0x%" PRIx64 ") => SBThread(%p)",
304 static_cast<void*>(process_sp.get()), tid, context,
305 static_cast<void*>(thread_sp.get()));
306
Greg Claytona4d87472013-01-18 23:41:08 +0000307 return sb_thread;
308}
309
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000310SBTarget
311SBProcess::GetTarget() const
312{
Greg Clayton5160ce52013-03-27 23:08:40 +0000313 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000314
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000315 SBTarget sb_target;
Greg Claytonb9556ac2012-01-30 07:41:31 +0000316 TargetSP target_sp;
Greg Claytonacdbe812012-01-30 09:04:36 +0000317 ProcessSP process_sp(GetSP());
318 if (process_sp)
Greg Claytonb9556ac2012-01-30 07:41:31 +0000319 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000320 target_sp = process_sp->GetTarget().shared_from_this();
Greg Claytonb9556ac2012-01-30 07:41:31 +0000321 sb_target.SetSP (target_sp);
322 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000323
Caroline Ticeceb6b132010-10-26 03:11:13 +0000324 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000325 log->Printf ("SBProcess(%p)::GetTarget () => SBTarget(%p)",
326 static_cast<void*>(process_sp.get()),
327 static_cast<void*>(target_sp.get()));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000328
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000329 return sb_target;
330}
331
332
333size_t
334SBProcess::PutSTDIN (const char *src, size_t src_len)
335{
Greg Clayton5160ce52013-03-27 23:08:40 +0000336 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000337
Caroline Ticeceb6b132010-10-26 03:11:13 +0000338 size_t ret_val = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +0000339 ProcessSP process_sp(GetSP());
340 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000341 {
342 Error error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000343 ret_val = process_sp->PutSTDIN (src, src_len, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000344 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000345
Caroline Ticeceb6b132010-10-26 03:11:13 +0000346 if (log)
Greg Clayton6fea17e2014-03-03 19:15:20 +0000347 log->Printf("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%" PRIu64 ") => %" PRIu64,
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000348 static_cast<void*>(process_sp.get()), src,
349 static_cast<uint64_t>(src_len),
350 static_cast<uint64_t>(ret_val));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000351
352 return ret_val;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000353}
354
355size_t
356SBProcess::GetSTDOUT (char *dst, size_t dst_len) const
357{
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000358 size_t bytes_read = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +0000359 ProcessSP process_sp(GetSP());
360 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000361 {
362 Error error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000363 bytes_read = process_sp->GetSTDOUT (dst, dst_len, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000364 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000365
Greg Clayton5160ce52013-03-27 23:08:40 +0000366 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000367 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +0000368 log->Printf ("SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%" PRIu64 ") => %" PRIu64,
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000369 static_cast<void*>(process_sp.get()),
370 static_cast<int>(bytes_read), dst,
371 static_cast<uint64_t>(dst_len),
372 static_cast<uint64_t>(bytes_read));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000373
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000374 return bytes_read;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000375}
376
377size_t
378SBProcess::GetSTDERR (char *dst, size_t dst_len) const
379{
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000380 size_t bytes_read = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +0000381 ProcessSP process_sp(GetSP());
382 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000383 {
384 Error error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000385 bytes_read = process_sp->GetSTDERR (dst, dst_len, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000386 }
Caroline Ticeceb6b132010-10-26 03:11:13 +0000387
Greg Clayton5160ce52013-03-27 23:08:40 +0000388 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000389 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +0000390 log->Printf ("SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%" PRIu64 ") => %" PRIu64,
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000391 static_cast<void*>(process_sp.get()),
392 static_cast<int>(bytes_read), dst,
393 static_cast<uint64_t>(dst_len),
394 static_cast<uint64_t>(bytes_read));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000395
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000396 return bytes_read;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000397}
398
Han Ming Ongab3b8b22012-11-17 00:21:04 +0000399size_t
400SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const
401{
402 size_t bytes_read = 0;
403 ProcessSP process_sp(GetSP());
404 if (process_sp)
405 {
406 Error error;
407 bytes_read = process_sp->GetAsyncProfileData (dst, dst_len, error);
408 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000409
Greg Clayton5160ce52013-03-27 23:08:40 +0000410 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Han Ming Ongab3b8b22012-11-17 00:21:04 +0000411 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +0000412 log->Printf ("SBProcess(%p)::GetProfileData (dst=\"%.*s\", dst_len=%" PRIu64 ") => %" PRIu64,
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000413 static_cast<void*>(process_sp.get()),
414 static_cast<int>(bytes_read), dst,
415 static_cast<uint64_t>(dst_len),
416 static_cast<uint64_t>(bytes_read));
417
Han Ming Ongab3b8b22012-11-17 00:21:04 +0000418 return bytes_read;
419}
420
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000421void
Jim Ingham2976d002010-08-26 21:32:51 +0000422SBProcess::ReportEventState (const SBEvent &event, FILE *out) const
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000423{
424 if (out == NULL)
425 return;
426
Greg Claytonacdbe812012-01-30 09:04:36 +0000427 ProcessSP process_sp(GetSP());
428 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000429 {
430 const StateType event_state = SBProcess::GetStateFromEvent (event);
431 char message[1024];
432 int message_len = ::snprintf (message,
433 sizeof (message),
Daniel Malead01b2952012-11-29 21:49:15 +0000434 "Process %" PRIu64 " %s\n",
Greg Claytonacdbe812012-01-30 09:04:36 +0000435 process_sp->GetID(),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000436 SBDebugger::StateAsCString (event_state));
437
438 if (message_len > 0)
439 ::fwrite (message, 1, message_len, out);
440 }
441}
442
443void
Jim Ingham2976d002010-08-26 21:32:51 +0000444SBProcess::AppendEventStateReport (const SBEvent &event, SBCommandReturnObject &result)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000445{
Greg Claytonacdbe812012-01-30 09:04:36 +0000446 ProcessSP process_sp(GetSP());
447 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000448 {
449 const StateType event_state = SBProcess::GetStateFromEvent (event);
450 char message[1024];
451 ::snprintf (message,
452 sizeof (message),
Daniel Malead01b2952012-11-29 21:49:15 +0000453 "Process %" PRIu64 " %s\n",
Greg Claytonacdbe812012-01-30 09:04:36 +0000454 process_sp->GetID(),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000455 SBDebugger::StateAsCString (event_state));
456
457 result.AppendMessage (message);
458 }
459}
460
461bool
Jim Ingham2976d002010-08-26 21:32:51 +0000462SBProcess::SetSelectedThread (const SBThread &thread)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000463{
Greg Claytonacdbe812012-01-30 09:04:36 +0000464 ProcessSP process_sp(GetSP());
465 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000466 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000467 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
468 return process_sp->GetThreadList().SetSelectedThreadByID (thread.GetThreadID());
Greg Claytonaf67cec2010-12-20 20:49:23 +0000469 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000470 return false;
471}
472
473bool
Greg Claytonea561dc2012-10-12 23:32:11 +0000474SBProcess::SetSelectedThreadByID (lldb::tid_t tid)
475{
Greg Clayton5160ce52013-03-27 23:08:40 +0000476 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000477
Caroline Ticeceb6b132010-10-26 03:11:13 +0000478 bool ret_val = false;
Greg Claytonacdbe812012-01-30 09:04:36 +0000479 ProcessSP process_sp(GetSP());
480 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000481 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000482 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
483 ret_val = process_sp->GetThreadList().SetSelectedThreadByID (tid);
Greg Claytonaf67cec2010-12-20 20:49:23 +0000484 }
Caroline Ticeceb6b132010-10-26 03:11:13 +0000485
486 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +0000487 log->Printf ("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4" PRIx64 ") => %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000488 static_cast<void*>(process_sp.get()), tid,
489 (ret_val ? "true" : "false"));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000490
491 return ret_val;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000492}
493
Jim Ingham18b46892012-07-13 20:18:18 +0000494bool
495SBProcess::SetSelectedThreadByIndexID (uint32_t index_id)
496{
Greg Clayton5160ce52013-03-27 23:08:40 +0000497 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Jim Ingham18b46892012-07-13 20:18:18 +0000498
499 bool ret_val = false;
500 ProcessSP process_sp(GetSP());
501 if (process_sp)
502 {
503 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
504 ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID (index_id);
505 }
506
507 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000508 log->Printf ("SBProcess(%p)::SetSelectedThreadByID (tid=0x%x) => %s",
509 static_cast<void*>(process_sp.get()), index_id,
510 (ret_val ? "true" : "false"));
Jim Ingham18b46892012-07-13 20:18:18 +0000511
512 return ret_val;
513}
514
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000515SBThread
516SBProcess::GetThreadAtIndex (size_t index)
517{
Greg Clayton5160ce52013-03-27 23:08:40 +0000518 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000519
Greg Clayton17a6ad02012-01-30 02:53:15 +0000520 SBThread sb_thread;
521 ThreadSP thread_sp;
Greg Claytonacdbe812012-01-30 09:04:36 +0000522 ProcessSP process_sp(GetSP());
523 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000524 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +0000525 Process::StopLocker stop_locker;
526 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
Greg Claytonacdbe812012-01-30 09:04:36 +0000527 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Greg Clayton7fdf9ef2012-04-05 16:12:35 +0000528 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
Greg Clayton17a6ad02012-01-30 02:53:15 +0000529 sb_thread.SetThread (thread_sp);
Greg Claytonaf67cec2010-12-20 20:49:23 +0000530 }
Caroline Ticeceb6b132010-10-26 03:11:13 +0000531
532 if (log)
Greg Clayton93aa84e2010-10-29 04:59:35 +0000533 log->Printf ("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000534 static_cast<void*>(process_sp.get()),
535 static_cast<uint32_t>(index),
536 static_cast<void*>(thread_sp.get()));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000537
Greg Clayton17a6ad02012-01-30 02:53:15 +0000538 return sb_thread;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000539}
540
Jim Inghambf2956a22013-01-08 23:22:42 +0000541uint32_t
Jason Molenda5e8dce42013-12-13 00:29:16 +0000542SBProcess::GetNumQueues ()
543{
544 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
545
546 uint32_t num_queues = 0;
547 ProcessSP process_sp(GetSP());
548 if (process_sp)
549 {
550 Process::StopLocker stop_locker;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000551
Jason Molenda5e8dce42013-12-13 00:29:16 +0000552 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
553 num_queues = process_sp->GetQueueList().GetSize();
554 }
555
556 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000557 log->Printf ("SBProcess(%p)::GetNumQueues () => %d",
558 static_cast<void*>(process_sp.get()), num_queues);
Jason Molenda5e8dce42013-12-13 00:29:16 +0000559
560 return num_queues;
561}
562
563SBQueue
564SBProcess::GetQueueAtIndex (size_t index)
565{
566 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
567
568 SBQueue sb_queue;
569 QueueSP queue_sp;
570 ProcessSP process_sp(GetSP());
571 if (process_sp)
572 {
573 Process::StopLocker stop_locker;
574 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
575 queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
576 sb_queue.SetQueue (queue_sp);
577 }
578
579 if (log)
Jason Molenda5e8dce42013-12-13 00:29:16 +0000580 log->Printf ("SBProcess(%p)::GetQueueAtIndex (index=%d) => SBQueue(%p)",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000581 static_cast<void*>(process_sp.get()),
582 static_cast<uint32_t>(index),
583 static_cast<void*>(queue_sp.get()));
Jason Molenda5e8dce42013-12-13 00:29:16 +0000584
585 return sb_queue;
586}
587
588
589uint32_t
Jim Inghambf2956a22013-01-08 23:22:42 +0000590SBProcess::GetStopID(bool include_expression_stops)
591{
592 ProcessSP process_sp(GetSP());
593 if (process_sp)
594 {
595 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
596 if (include_expression_stops)
597 return process_sp->GetStopID();
598 else
599 return process_sp->GetLastNaturalStopID();
600 }
601 return 0;
602}
603
Ilia K38810f42015-05-20 10:15:47 +0000604SBEvent
605SBProcess::GetStopEventForStopID(uint32_t stop_id)
606{
607 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
608
609 SBEvent sb_event;
610 EventSP event_sp;
611 ProcessSP process_sp(GetSP());
612 if (process_sp)
613 {
614 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
615 event_sp = process_sp->GetStopEventForStopID(stop_id);
616 sb_event.reset(event_sp);
617 }
618
619 if (log)
620 log->Printf ("SBProcess(%p)::GetStopEventForStopID (stop_id=%" PRIu32 ") => SBEvent(%p)",
621 static_cast<void*>(process_sp.get()),
622 stop_id,
623 static_cast<void*>(event_sp.get()));
624
625 return sb_event;
626}
627
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000628StateType
629SBProcess::GetState ()
630{
Caroline Ticeceb6b132010-10-26 03:11:13 +0000631
Caroline Ticeceb6b132010-10-26 03:11:13 +0000632 StateType ret_val = eStateInvalid;
Greg Claytonacdbe812012-01-30 09:04:36 +0000633 ProcessSP process_sp(GetSP());
634 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000635 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000636 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
637 ret_val = process_sp->GetState();
Greg Claytonaf67cec2010-12-20 20:49:23 +0000638 }
Caroline Ticeceb6b132010-10-26 03:11:13 +0000639
Greg Clayton5160ce52013-03-27 23:08:40 +0000640 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000641 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000642 log->Printf ("SBProcess(%p)::GetState () => %s",
643 static_cast<void*>(process_sp.get()),
Caroline Tice750cd172010-10-26 23:49:36 +0000644 lldb_private::StateAsCString (ret_val));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000645
646 return ret_val;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000647}
648
649
650int
651SBProcess::GetExitStatus ()
652{
Greg Clayton48381312010-10-30 04:51:46 +0000653 int exit_status = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +0000654 ProcessSP process_sp(GetSP());
655 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000656 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000657 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
658 exit_status = process_sp->GetExitStatus ();
Greg Claytonaf67cec2010-12-20 20:49:23 +0000659 }
Greg Clayton5160ce52013-03-27 23:08:40 +0000660 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Clayton48381312010-10-30 04:51:46 +0000661 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000662 log->Printf ("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)",
663 static_cast<void*>(process_sp.get()), exit_status,
664 exit_status);
Greg Clayton48381312010-10-30 04:51:46 +0000665
666 return exit_status;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000667}
668
669const char *
670SBProcess::GetExitDescription ()
671{
Greg Clayton48381312010-10-30 04:51:46 +0000672 const char *exit_desc = NULL;
Greg Claytonacdbe812012-01-30 09:04:36 +0000673 ProcessSP process_sp(GetSP());
674 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000675 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000676 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
677 exit_desc = process_sp->GetExitDescription ();
Greg Claytonaf67cec2010-12-20 20:49:23 +0000678 }
Greg Clayton5160ce52013-03-27 23:08:40 +0000679 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Clayton48381312010-10-30 04:51:46 +0000680 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000681 log->Printf ("SBProcess(%p)::GetExitDescription () => %s",
682 static_cast<void*>(process_sp.get()), exit_desc);
Greg Clayton48381312010-10-30 04:51:46 +0000683 return exit_desc;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000684}
685
686lldb::pid_t
687SBProcess::GetProcessID ()
688{
Caroline Ticeceb6b132010-10-26 03:11:13 +0000689 lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
Greg Claytonacdbe812012-01-30 09:04:36 +0000690 ProcessSP process_sp(GetSP());
691 if (process_sp)
692 ret_val = process_sp->GetID();
Caroline Ticeceb6b132010-10-26 03:11:13 +0000693
Greg Clayton5160ce52013-03-27 23:08:40 +0000694 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000695 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000696 log->Printf ("SBProcess(%p)::GetProcessID () => %" PRIu64,
697 static_cast<void*>(process_sp.get()), ret_val);
Caroline Ticeceb6b132010-10-26 03:11:13 +0000698
699 return ret_val;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000700}
701
Greg Clayton949e8222013-01-16 17:29:04 +0000702uint32_t
703SBProcess::GetUniqueID()
704{
705 uint32_t ret_val = 0;
706 ProcessSP process_sp(GetSP());
707 if (process_sp)
708 ret_val = process_sp->GetUniqueID();
Greg Clayton5160ce52013-03-27 23:08:40 +0000709 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Clayton949e8222013-01-16 17:29:04 +0000710 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000711 log->Printf ("SBProcess(%p)::GetUniqueID () => %" PRIu32,
712 static_cast<void*>(process_sp.get()), ret_val);
Greg Clayton949e8222013-01-16 17:29:04 +0000713 return ret_val;
714}
715
Johnny Chencf386e22011-03-01 22:56:31 +0000716ByteOrder
717SBProcess::GetByteOrder () const
718{
719 ByteOrder byteOrder = eByteOrderInvalid;
Greg Claytonacdbe812012-01-30 09:04:36 +0000720 ProcessSP process_sp(GetSP());
721 if (process_sp)
722 byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000723
Greg Clayton5160ce52013-03-27 23:08:40 +0000724 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Johnny Chencf386e22011-03-01 22:56:31 +0000725 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000726 log->Printf ("SBProcess(%p)::GetByteOrder () => %d",
727 static_cast<void*>(process_sp.get()), byteOrder);
Johnny Chencf386e22011-03-01 22:56:31 +0000728
729 return byteOrder;
730}
731
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000732uint32_t
733SBProcess::GetAddressByteSize () const
734{
Caroline Ticeceb6b132010-10-26 03:11:13 +0000735 uint32_t size = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +0000736 ProcessSP process_sp(GetSP());
737 if (process_sp)
738 size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
Caroline Ticeceb6b132010-10-26 03:11:13 +0000739
Greg Clayton5160ce52013-03-27 23:08:40 +0000740 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000741 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000742 log->Printf ("SBProcess(%p)::GetAddressByteSize () => %d",
743 static_cast<void*>(process_sp.get()), size);
Caroline Ticeceb6b132010-10-26 03:11:13 +0000744
745 return size;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000746}
747
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000748SBError
749SBProcess::Continue ()
750{
Greg Clayton5160ce52013-03-27 23:08:40 +0000751 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000752
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000753 SBError sb_error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000754 ProcessSP process_sp(GetSP());
755
756 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000757 log->Printf ("SBProcess(%p)::Continue ()...",
758 static_cast<void*>(process_sp.get()));
Greg Claytonacdbe812012-01-30 09:04:36 +0000759
760 if (process_sp)
Greg Clayton5d5028b2010-10-06 03:53:16 +0000761 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000762 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000763
Greg Claytondc6224e2014-10-21 01:00:42 +0000764 if (process_sp->GetTarget().GetDebugger().GetAsyncExecution ())
765 sb_error.ref() = process_sp->Resume ();
766 else
767 sb_error.ref() = process_sp->ResumeSynchronous (NULL);
Greg Clayton5d5028b2010-10-06 03:53:16 +0000768 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000769 else
770 sb_error.SetErrorString ("SBProcess is invalid");
771
Caroline Ticeceb6b132010-10-26 03:11:13 +0000772 if (log)
773 {
774 SBStream sstr;
775 sb_error.GetDescription (sstr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000776 log->Printf ("SBProcess(%p)::Continue () => SBError (%p): %s",
777 static_cast<void*>(process_sp.get()),
778 static_cast<void*>(sb_error.get()), sstr.GetData());
Caroline Ticeceb6b132010-10-26 03:11:13 +0000779 }
780
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000781 return sb_error;
782}
783
784
785SBError
786SBProcess::Destroy ()
787{
788 SBError sb_error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000789 ProcessSP process_sp(GetSP());
790 if (process_sp)
Greg Clayton6779606a2011-01-22 23:43:18 +0000791 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000792 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Jason Molendaede31932015-04-17 05:01:58 +0000793 sb_error.SetError(process_sp->Destroy(false));
Greg Clayton6779606a2011-01-22 23:43:18 +0000794 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000795 else
796 sb_error.SetErrorString ("SBProcess is invalid");
797
Greg Clayton5160ce52013-03-27 23:08:40 +0000798 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Clayton48381312010-10-30 04:51:46 +0000799 if (log)
800 {
801 SBStream sstr;
802 sb_error.GetDescription (sstr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000803 log->Printf ("SBProcess(%p)::Destroy () => SBError (%p): %s",
804 static_cast<void*>(process_sp.get()),
805 static_cast<void*>(sb_error.get()), sstr.GetData());
Greg Clayton48381312010-10-30 04:51:46 +0000806 }
807
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000808 return sb_error;
809}
810
811
812SBError
813SBProcess::Stop ()
814{
815 SBError sb_error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000816 ProcessSP process_sp(GetSP());
817 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000818 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000819 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
820 sb_error.SetError (process_sp->Halt());
Greg Claytonaf67cec2010-12-20 20:49:23 +0000821 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000822 else
823 sb_error.SetErrorString ("SBProcess is invalid");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000824
Greg Clayton5160ce52013-03-27 23:08:40 +0000825 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000826 if (log)
827 {
828 SBStream sstr;
829 sb_error.GetDescription (sstr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000830 log->Printf ("SBProcess(%p)::Stop () => SBError (%p): %s",
831 static_cast<void*>(process_sp.get()),
832 static_cast<void*>(sb_error.get()), sstr.GetData());
Caroline Ticeceb6b132010-10-26 03:11:13 +0000833 }
834
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000835 return sb_error;
836}
837
838SBError
839SBProcess::Kill ()
840{
841 SBError sb_error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000842 ProcessSP process_sp(GetSP());
843 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000844 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000845 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Jason Molendaede31932015-04-17 05:01:58 +0000846 sb_error.SetError (process_sp->Destroy(true));
Greg Claytonaf67cec2010-12-20 20:49:23 +0000847 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000848 else
849 sb_error.SetErrorString ("SBProcess is invalid");
Caroline Ticeceb6b132010-10-26 03:11:13 +0000850
Greg Clayton5160ce52013-03-27 23:08:40 +0000851 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000852 if (log)
853 {
854 SBStream sstr;
855 sb_error.GetDescription (sstr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000856 log->Printf ("SBProcess(%p)::Kill () => SBError (%p): %s",
857 static_cast<void*>(process_sp.get()),
858 static_cast<void*>(sb_error.get()), sstr.GetData());
Caroline Ticeceb6b132010-10-26 03:11:13 +0000859 }
860
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000861 return sb_error;
862}
863
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000864SBError
865SBProcess::Detach ()
866{
Jim Inghamacff8952013-05-02 00:27:30 +0000867 // FIXME: This should come from a process default.
868 bool keep_stopped = false;
869 return Detach (keep_stopped);
870}
871
872SBError
873SBProcess::Detach (bool keep_stopped)
874{
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000875 SBError sb_error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000876 ProcessSP process_sp(GetSP());
877 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000878 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000879 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Jim Inghamacff8952013-05-02 00:27:30 +0000880 sb_error.SetError (process_sp->Detach(keep_stopped));
Greg Claytonaf67cec2010-12-20 20:49:23 +0000881 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000882 else
883 sb_error.SetErrorString ("SBProcess is invalid");
884
885 return sb_error;
886}
887
888SBError
Greg Clayton48381312010-10-30 04:51:46 +0000889SBProcess::Signal (int signo)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000890{
891 SBError sb_error;
Greg Claytonacdbe812012-01-30 09:04:36 +0000892 ProcessSP process_sp(GetSP());
893 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000894 {
Greg Claytonacdbe812012-01-30 09:04:36 +0000895 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
896 sb_error.SetError (process_sp->Signal (signo));
Greg Claytonaf67cec2010-12-20 20:49:23 +0000897 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000898 else
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000899 sb_error.SetErrorString ("SBProcess is invalid");
Greg Clayton5160ce52013-03-27 23:08:40 +0000900 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Clayton48381312010-10-30 04:51:46 +0000901 if (log)
902 {
903 SBStream sstr;
904 sb_error.GetDescription (sstr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000905 log->Printf ("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s",
906 static_cast<void*>(process_sp.get()), signo,
907 static_cast<void*>(sb_error.get()), sstr.GetData());
Greg Clayton48381312010-10-30 04:51:46 +0000908 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000909 return sb_error;
910}
911
Todd Fiala802dc4022014-06-23 19:30:49 +0000912SBUnixSignals
913SBProcess::GetUnixSignals()
914{
915 SBUnixSignals sb_unix_signals;
916 ProcessSP process_sp(GetSP());
917 if (process_sp)
918 {
919 sb_unix_signals.SetSP(process_sp);
920 }
921
922 return sb_unix_signals;
923}
924
Jim Inghamcfc09352012-07-27 23:57:19 +0000925void
926SBProcess::SendAsyncInterrupt ()
927{
928 ProcessSP process_sp(GetSP());
929 if (process_sp)
930 {
931 process_sp->SendAsyncInterrupt ();
932 }
933}
934
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000935SBThread
Greg Clayton48381312010-10-30 04:51:46 +0000936SBProcess::GetThreadByID (tid_t tid)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000937{
Greg Clayton48381312010-10-30 04:51:46 +0000938 SBThread sb_thread;
Greg Clayton17a6ad02012-01-30 02:53:15 +0000939 ThreadSP thread_sp;
Greg Claytonacdbe812012-01-30 09:04:36 +0000940 ProcessSP process_sp(GetSP());
941 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +0000942 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +0000943 Process::StopLocker stop_locker;
944 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
Hafiz Abid Qadeer5bf72c42015-02-11 16:37:17 +0000945 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Greg Clayton7fdf9ef2012-04-05 16:12:35 +0000946 thread_sp = process_sp->GetThreadList().FindThreadByID (tid, can_update);
Greg Clayton17a6ad02012-01-30 02:53:15 +0000947 sb_thread.SetThread (thread_sp);
Greg Claytonaf67cec2010-12-20 20:49:23 +0000948 }
Greg Clayton48381312010-10-30 04:51:46 +0000949
Greg Clayton5160ce52013-03-27 23:08:40 +0000950 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Clayton48381312010-10-30 04:51:46 +0000951 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +0000952 log->Printf ("SBProcess(%p)::GetThreadByID (tid=0x%4.4" PRIx64 ") => SBThread (%p)",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000953 static_cast<void*>(process_sp.get()), tid,
954 static_cast<void*>(thread_sp.get()));
Greg Clayton48381312010-10-30 04:51:46 +0000955
956 return sb_thread;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000957}
958
Jim Ingham18b46892012-07-13 20:18:18 +0000959SBThread
960SBProcess::GetThreadByIndexID (uint32_t index_id)
961{
962 SBThread sb_thread;
963 ThreadSP thread_sp;
964 ProcessSP process_sp(GetSP());
965 if (process_sp)
966 {
Jim Ingham18b46892012-07-13 20:18:18 +0000967 Process::StopLocker stop_locker;
968 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
Hafiz Abid Qadeer5bf72c42015-02-11 16:37:17 +0000969 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
Jim Ingham18b46892012-07-13 20:18:18 +0000970 thread_sp = process_sp->GetThreadList().FindThreadByIndexID (index_id, can_update);
971 sb_thread.SetThread (thread_sp);
972 }
973
Greg Clayton5160ce52013-03-27 23:08:40 +0000974 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Jim Ingham18b46892012-07-13 20:18:18 +0000975 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000976 log->Printf ("SBProcess(%p)::GetThreadByID (tid=0x%x) => SBThread (%p)",
977 static_cast<void*>(process_sp.get()), index_id,
978 static_cast<void*>(thread_sp.get()));
Jim Ingham18b46892012-07-13 20:18:18 +0000979
980 return sb_thread;
981}
982
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000983StateType
984SBProcess::GetStateFromEvent (const SBEvent &event)
985{
Greg Clayton5160ce52013-03-27 23:08:40 +0000986 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000987
Caroline Ticeceb6b132010-10-26 03:11:13 +0000988 StateType ret_val = Process::ProcessEventData::GetStateFromEvent (event.get());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000989
Caroline Ticeceb6b132010-10-26 03:11:13 +0000990 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000991 log->Printf ("SBProcess::GetStateFromEvent (event.sp=%p) => %s",
992 static_cast<void*>(event.get()),
Caroline Tice750cd172010-10-26 23:49:36 +0000993 lldb_private::StateAsCString (ret_val));
Caroline Ticeceb6b132010-10-26 03:11:13 +0000994
995 return ret_val;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000996}
997
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000998bool
999SBProcess::GetRestartedFromEvent (const SBEvent &event)
1000{
Greg Clayton66111032010-06-23 01:19:29 +00001001 return Process::ProcessEventData::GetRestartedFromEvent (event.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001002}
1003
Jim Ingham0161b492013-02-09 01:29:05 +00001004size_t
1005SBProcess::GetNumRestartedReasonsFromEvent (const lldb::SBEvent &event)
1006{
1007 return Process::ProcessEventData::GetNumRestartedReasons(event.get());
1008}
1009
1010const char *
1011SBProcess::GetRestartedReasonAtIndexFromEvent (const lldb::SBEvent &event, size_t idx)
1012{
1013 return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx);
1014}
1015
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001016SBProcess
1017SBProcess::GetProcessFromEvent (const SBEvent &event)
1018{
Greg Clayton66111032010-06-23 01:19:29 +00001019 SBProcess process(Process::ProcessEventData::GetProcessFromEvent (event.get()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001020 return process;
1021}
1022
Jim Inghame6bc6cb2012-02-08 05:23:15 +00001023bool
Ilia K06d28552015-05-15 09:29:09 +00001024SBProcess::GetInterruptedFromEvent (const SBEvent &event)
1025{
1026 return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
1027}
1028
1029bool
Jim Inghame6bc6cb2012-02-08 05:23:15 +00001030SBProcess::EventIsProcessEvent (const SBEvent &event)
1031{
Ilia Kf9e5dc12015-03-21 11:11:07 +00001032 return event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass();
Jim Inghame6bc6cb2012-02-08 05:23:15 +00001033}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001034
1035SBBroadcaster
1036SBProcess::GetBroadcaster () const
1037{
Greg Clayton5160ce52013-03-27 23:08:40 +00001038 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +00001039
Greg Claytonacdbe812012-01-30 09:04:36 +00001040 ProcessSP process_sp(GetSP());
1041
1042 SBBroadcaster broadcaster(process_sp.get(), false);
Caroline Ticeceb6b132010-10-26 03:11:13 +00001043
1044 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001045 log->Printf ("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)",
1046 static_cast<void*>(process_sp.get()),
1047 static_cast<void*>(broadcaster.get()));
Caroline Ticeceb6b132010-10-26 03:11:13 +00001048
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001049 return broadcaster;
1050}
1051
Jim Ingham4bddaeb2012-02-16 06:50:00 +00001052const char *
1053SBProcess::GetBroadcasterClass ()
1054{
1055 return Process::GetStaticBroadcasterClass().AsCString();
1056}
1057
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001058size_t
1059SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error)
1060{
Greg Clayton5160ce52013-03-27 23:08:40 +00001061 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Caroline Ticeceb6b132010-10-26 03:11:13 +00001062
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001063 size_t bytes_read = 0;
1064
Greg Claytonacdbe812012-01-30 09:04:36 +00001065 ProcessSP process_sp(GetSP());
1066
Greg Clayton48381312010-10-30 04:51:46 +00001067 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001068 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p))...",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001069 static_cast<void*>(process_sp.get()), addr,
1070 static_cast<void*>(dst), static_cast<uint64_t>(dst_len),
1071 static_cast<void*>(sb_error.get()));
1072
Greg Claytonacdbe812012-01-30 09:04:36 +00001073 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001074 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001075 Process::StopLocker stop_locker;
1076 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1077 {
1078 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1079 bytes_read = process_sp->ReadMemory (addr, dst, dst_len, sb_error.ref());
1080 }
1081 else
1082 {
Greg Claytonc9858e42012-04-06 02:17:47 +00001083 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001084 log->Printf ("SBProcess(%p)::ReadMemory() => error: process is running",
1085 static_cast<void*>(process_sp.get()));
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001086 sb_error.SetErrorString("process is running");
1087 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001088 }
1089 else
1090 {
1091 sb_error.SetErrorString ("SBProcess is invalid");
1092 }
1093
Caroline Ticeceb6b132010-10-26 03:11:13 +00001094 if (log)
Greg Clayton93aa84e2010-10-29 04:59:35 +00001095 {
1096 SBStream sstr;
1097 sb_error.GetDescription (sstr);
Daniel Malead01b2952012-11-29 21:49:15 +00001098 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64,
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001099 static_cast<void*>(process_sp.get()), addr,
1100 static_cast<void*>(dst), static_cast<uint64_t>(dst_len),
1101 static_cast<void*>(sb_error.get()), sstr.GetData(),
1102 static_cast<uint64_t>(bytes_read));
Greg Clayton93aa84e2010-10-29 04:59:35 +00001103 }
Caroline Ticeceb6b132010-10-26 03:11:13 +00001104
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001105 return bytes_read;
1106}
1107
1108size_t
Greg Claytone91b7952011-12-15 03:14:23 +00001109SBProcess::ReadCStringFromMemory (addr_t addr, void *buf, size_t size, lldb::SBError &sb_error)
1110{
1111 size_t bytes_read = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +00001112 ProcessSP process_sp(GetSP());
1113 if (process_sp)
Greg Claytone91b7952011-12-15 03:14:23 +00001114 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001115 Process::StopLocker stop_locker;
1116 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1117 {
1118 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1119 bytes_read = process_sp->ReadCStringFromMemory (addr, (char *)buf, size, sb_error.ref());
1120 }
1121 else
1122 {
Greg Clayton5160ce52013-03-27 23:08:40 +00001123 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytonc9858e42012-04-06 02:17:47 +00001124 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001125 log->Printf ("SBProcess(%p)::ReadCStringFromMemory() => error: process is running",
1126 static_cast<void*>(process_sp.get()));
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001127 sb_error.SetErrorString("process is running");
1128 }
Greg Claytone91b7952011-12-15 03:14:23 +00001129 }
1130 else
1131 {
1132 sb_error.SetErrorString ("SBProcess is invalid");
1133 }
1134 return bytes_read;
1135}
1136
1137uint64_t
1138SBProcess::ReadUnsignedFromMemory (addr_t addr, uint32_t byte_size, lldb::SBError &sb_error)
1139{
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001140 uint64_t value = 0;
Greg Claytonacdbe812012-01-30 09:04:36 +00001141 ProcessSP process_sp(GetSP());
1142 if (process_sp)
Greg Claytone91b7952011-12-15 03:14:23 +00001143 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001144 Process::StopLocker stop_locker;
1145 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1146 {
1147 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1148 value = process_sp->ReadUnsignedIntegerFromMemory (addr, byte_size, 0, sb_error.ref());
1149 }
1150 else
1151 {
Greg Clayton5160ce52013-03-27 23:08:40 +00001152 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytonc9858e42012-04-06 02:17:47 +00001153 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001154 log->Printf ("SBProcess(%p)::ReadUnsignedFromMemory() => error: process is running",
1155 static_cast<void*>(process_sp.get()));
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001156 sb_error.SetErrorString("process is running");
1157 }
Greg Claytone91b7952011-12-15 03:14:23 +00001158 }
1159 else
1160 {
1161 sb_error.SetErrorString ("SBProcess is invalid");
1162 }
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001163 return value;
Greg Claytone91b7952011-12-15 03:14:23 +00001164}
1165
1166lldb::addr_t
1167SBProcess::ReadPointerFromMemory (addr_t addr, lldb::SBError &sb_error)
1168{
1169 lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
Greg Claytonacdbe812012-01-30 09:04:36 +00001170 ProcessSP process_sp(GetSP());
1171 if (process_sp)
Greg Claytone91b7952011-12-15 03:14:23 +00001172 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001173 Process::StopLocker stop_locker;
1174 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1175 {
1176 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1177 ptr = process_sp->ReadPointerFromMemory (addr, sb_error.ref());
1178 }
1179 else
1180 {
Greg Clayton5160ce52013-03-27 23:08:40 +00001181 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytonc9858e42012-04-06 02:17:47 +00001182 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001183 log->Printf ("SBProcess(%p)::ReadPointerFromMemory() => error: process is running",
1184 static_cast<void*>(process_sp.get()));
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001185 sb_error.SetErrorString("process is running");
1186 }
Greg Claytone91b7952011-12-15 03:14:23 +00001187 }
1188 else
1189 {
1190 sb_error.SetErrorString ("SBProcess is invalid");
1191 }
1192 return ptr;
1193}
1194
1195size_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001196SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error)
1197{
1198 size_t bytes_written = 0;
1199
Greg Clayton5160ce52013-03-27 23:08:40 +00001200 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytonacdbe812012-01-30 09:04:36 +00001201
1202 ProcessSP process_sp(GetSP());
1203
Greg Clayton48381312010-10-30 04:51:46 +00001204 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001205 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 ", src=%p, src_len=%" PRIu64 ", SBError (%p))...",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001206 static_cast<void*>(process_sp.get()), addr,
1207 static_cast<const void*>(src),
1208 static_cast<uint64_t>(src_len),
1209 static_cast<void*>(sb_error.get()));
Greg Clayton48381312010-10-30 04:51:46 +00001210
Greg Claytonacdbe812012-01-30 09:04:36 +00001211 if (process_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001212 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001213 Process::StopLocker stop_locker;
1214 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1215 {
1216 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1217 bytes_written = process_sp->WriteMemory (addr, src, src_len, sb_error.ref());
1218 }
1219 else
1220 {
Greg Claytonc9858e42012-04-06 02:17:47 +00001221 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001222 log->Printf ("SBProcess(%p)::WriteMemory() => error: process is running",
1223 static_cast<void*>(process_sp.get()));
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001224 sb_error.SetErrorString("process is running");
1225 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001226 }
1227
Greg Clayton48381312010-10-30 04:51:46 +00001228 if (log)
1229 {
1230 SBStream sstr;
1231 sb_error.GetDescription (sstr);
Daniel Malead01b2952012-11-29 21:49:15 +00001232 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 ", src=%p, src_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64,
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001233 static_cast<void*>(process_sp.get()), addr,
1234 static_cast<const void*>(src),
1235 static_cast<uint64_t>(src_len),
1236 static_cast<void*>(sb_error.get()), sstr.GetData(),
1237 static_cast<uint64_t>(bytes_written));
Greg Clayton48381312010-10-30 04:51:46 +00001238 }
1239
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001240 return bytes_written;
1241}
1242
Caroline Ticedde9cff2010-09-20 05:20:02 +00001243bool
1244SBProcess::GetDescription (SBStream &description)
1245{
Greg Claytonda7bc7d2011-11-13 06:57:31 +00001246 Stream &strm = description.ref();
1247
Greg Claytonacdbe812012-01-30 09:04:36 +00001248 ProcessSP process_sp(GetSP());
1249 if (process_sp)
Caroline Ticedde9cff2010-09-20 05:20:02 +00001250 {
1251 char path[PATH_MAX];
1252 GetTarget().GetExecutable().GetPath (path, sizeof(path));
Greg Claytonacdbe812012-01-30 09:04:36 +00001253 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
Greg Clayton1d273162010-10-06 03:09:58 +00001254 const char *exe_name = NULL;
1255 if (exe_module)
1256 exe_name = exe_module->GetFileSpec().GetFilename().AsCString();
1257
Daniel Malead01b2952012-11-29 21:49:15 +00001258 strm.Printf ("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s",
Greg Claytonacdbe812012-01-30 09:04:36 +00001259 process_sp->GetID(),
Greg Claytonda7bc7d2011-11-13 06:57:31 +00001260 lldb_private::StateAsCString (GetState()),
1261 GetNumThreads(),
1262 exe_name ? ", executable = " : "",
1263 exe_name ? exe_name : "");
Caroline Ticedde9cff2010-09-20 05:20:02 +00001264 }
1265 else
Greg Claytonda7bc7d2011-11-13 06:57:31 +00001266 strm.PutCString ("No value");
Caroline Ticedde9cff2010-09-20 05:20:02 +00001267
1268 return true;
1269}
Greg Clayton8f343b02010-11-04 01:54:29 +00001270
1271uint32_t
Johnny Chenf9ef60d2012-05-23 22:34:34 +00001272SBProcess::GetNumSupportedHardwareWatchpoints (lldb::SBError &sb_error) const
1273{
Greg Clayton5160ce52013-03-27 23:08:40 +00001274 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Johnny Chenf9ef60d2012-05-23 22:34:34 +00001275
1276 uint32_t num = 0;
1277 ProcessSP process_sp(GetSP());
1278 if (process_sp)
1279 {
1280 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1281 sb_error.SetError(process_sp->GetWatchpointSupportInfo (num));
Johnny Chenf9ef60d2012-05-23 22:34:34 +00001282 if (log)
1283 log->Printf ("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001284 static_cast<void*>(process_sp.get()), num);
Johnny Chenf9ef60d2012-05-23 22:34:34 +00001285 }
1286 else
1287 {
1288 sb_error.SetErrorString ("SBProcess is invalid");
1289 }
1290 return num;
1291}
1292
1293uint32_t
Greg Clayton8f343b02010-11-04 01:54:29 +00001294SBProcess::LoadImage (lldb::SBFileSpec &sb_image_spec, lldb::SBError &sb_error)
1295{
Greg Claytonacdbe812012-01-30 09:04:36 +00001296 ProcessSP process_sp(GetSP());
1297 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +00001298 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001299 Process::StopLocker stop_locker;
1300 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1301 {
1302 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1303 return process_sp->LoadImage (*sb_image_spec, sb_error.ref());
1304 }
1305 else
1306 {
Greg Clayton5160ce52013-03-27 23:08:40 +00001307 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytonc9858e42012-04-06 02:17:47 +00001308 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001309 log->Printf ("SBProcess(%p)::LoadImage() => error: process is running",
1310 static_cast<void*>(process_sp.get()));
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001311 sb_error.SetErrorString("process is running");
1312 }
Greg Claytonaf67cec2010-12-20 20:49:23 +00001313 }
Greg Clayton8f343b02010-11-04 01:54:29 +00001314 return LLDB_INVALID_IMAGE_TOKEN;
1315}
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001316
Greg Clayton8f343b02010-11-04 01:54:29 +00001317lldb::SBError
1318SBProcess::UnloadImage (uint32_t image_token)
1319{
1320 lldb::SBError sb_error;
Greg Claytonacdbe812012-01-30 09:04:36 +00001321 ProcessSP process_sp(GetSP());
1322 if (process_sp)
Greg Claytonaf67cec2010-12-20 20:49:23 +00001323 {
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001324 Process::StopLocker stop_locker;
1325 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1326 {
1327 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1328 sb_error.SetError (process_sp->UnloadImage (image_token));
1329 }
1330 else
1331 {
Greg Clayton5160ce52013-03-27 23:08:40 +00001332 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
Greg Claytonc9858e42012-04-06 02:17:47 +00001333 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001334 log->Printf ("SBProcess(%p)::UnloadImage() => error: process is running",
1335 static_cast<void*>(process_sp.get()));
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001336 sb_error.SetErrorString("process is running");
1337 }
Greg Claytonaf67cec2010-12-20 20:49:23 +00001338 }
Greg Clayton8f343b02010-11-04 01:54:29 +00001339 else
1340 sb_error.SetErrorString("invalid process");
1341 return sb_error;
1342}
Jason Molenda8c713372013-11-05 11:00:35 +00001343
Jason Molendaa3329782014-03-29 18:54:20 +00001344lldb::SBError
1345SBProcess::SendEventData (const char *event_data)
1346{
1347 lldb::SBError sb_error;
1348 ProcessSP process_sp(GetSP());
1349 if (process_sp)
1350 {
1351 Process::StopLocker stop_locker;
1352 if (stop_locker.TryLock(&process_sp->GetRunLock()))
1353 {
1354 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
1355 sb_error.SetError (process_sp->SendEventData (event_data));
1356 }
1357 else
1358 {
1359 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1360 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001361 log->Printf ("SBProcess(%p)::SendEventData() => error: process is running",
1362 static_cast<void*>(process_sp.get()));
Jason Molendaa3329782014-03-29 18:54:20 +00001363 sb_error.SetErrorString("process is running");
1364 }
1365 }
1366 else
1367 sb_error.SetErrorString("invalid process");
1368 return sb_error;
1369}
1370
Jason Molenda8c713372013-11-05 11:00:35 +00001371uint32_t
Jason Molenda95d005c2013-11-06 03:07:33 +00001372SBProcess::GetNumExtendedBacktraceTypes ()
Jason Molenda8c713372013-11-05 11:00:35 +00001373{
1374 ProcessSP process_sp(GetSP());
1375 if (process_sp && process_sp->GetSystemRuntime())
1376 {
1377 SystemRuntime *runtime = process_sp->GetSystemRuntime();
Jason Molenda95d005c2013-11-06 03:07:33 +00001378 return runtime->GetExtendedBacktraceTypes().size();
Jason Molenda8c713372013-11-05 11:00:35 +00001379 }
1380 return 0;
1381}
1382
1383const char *
Jason Molenda95d005c2013-11-06 03:07:33 +00001384SBProcess::GetExtendedBacktraceTypeAtIndex (uint32_t idx)
Jason Molenda8c713372013-11-05 11:00:35 +00001385{
1386 ProcessSP process_sp(GetSP());
1387 if (process_sp && process_sp->GetSystemRuntime())
1388 {
1389 SystemRuntime *runtime = process_sp->GetSystemRuntime();
Jason Molenda008c45f2013-11-12 23:33:32 +00001390 const std::vector<ConstString> &names = runtime->GetExtendedBacktraceTypes();
Jason Molenda8c713372013-11-05 11:00:35 +00001391 if (idx < names.size())
1392 {
1393 return names[idx].AsCString();
1394 }
1395 else
1396 {
1397 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1398 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001399 log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => error: requested extended backtrace name out of bounds",
1400 static_cast<void*>(process_sp.get()));
Jason Molenda8c713372013-11-05 11:00:35 +00001401 }
1402 }
1403 return NULL;
1404}
Kuba Breckaa51ea382014-09-06 01:33:13 +00001405
1406SBThreadCollection
1407SBProcess::GetHistoryThreads (addr_t addr)
1408{
1409 ProcessSP process_sp(GetSP());
1410 SBThreadCollection threads;
1411 if (process_sp)
1412 {
1413 threads = SBThreadCollection(process_sp->GetHistoryThreads(addr));
1414 }
1415 return threads;
1416}
Kuba Brecka63927542014-10-11 01:59:32 +00001417
1418bool
1419SBProcess::IsInstrumentationRuntimePresent(InstrumentationRuntimeType type)
1420{
1421 ProcessSP process_sp(GetSP());
1422 if (! process_sp)
1423 return false;
1424
1425 InstrumentationRuntimeSP runtime_sp = process_sp->GetInstrumentationRuntime(type);
1426
1427 if (! runtime_sp.get())
1428 return false;
1429
1430 return runtime_sp->IsActive();
1431}