blob: cebe440e38e47d31dafbaa46eba1e29a87858800 [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001//===-- Process.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
Daniel Malea93a64302012-12-05 00:20:57 +000010#include "lldb/lldb-python.h"
11
Chris Lattner30fdc8d2010-06-08 16:52:24 +000012#include "lldb/Target/Process.h"
13
14#include "lldb/lldb-private-log.h"
15
16#include "lldb/Breakpoint/StoppointCallbackContext.h"
17#include "lldb/Breakpoint/BreakpointLocation.h"
18#include "lldb/Core/Event.h"
Caroline Ticeef5c6d02010-11-16 05:07:41 +000019#include "lldb/Core/ConnectionFileDescriptor.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000020#include "lldb/Core/Debugger.h"
21#include "lldb/Core/Log.h"
Greg Clayton1f746072012-08-29 21:13:06 +000022#include "lldb/Core/Module.h"
Jim Ingham1460e4b2014-01-10 23:46:59 +000023#include "lldb/Symbol/Symbol.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000024#include "lldb/Core/PluginManager.h"
25#include "lldb/Core/State.h"
Greg Clayton44d93782014-01-27 23:43:24 +000026#include "lldb/Core/StreamFile.h"
Greg Claytoneb0103f2011-04-07 22:46:35 +000027#include "lldb/Expression/ClangUserExpression.h"
Caroline Tice3df9a8d2010-09-04 00:03:46 +000028#include "lldb/Interpreter/CommandInterpreter.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000029#include "lldb/Host/Host.h"
Greg Clayton100eb932014-07-02 21:10:39 +000030#include "lldb/Host/Pipe.h"
Greg Clayton44d93782014-01-27 23:43:24 +000031#include "lldb/Host/Terminal.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000032#include "lldb/Target/ABI.h"
Greg Clayton8f343b02010-11-04 01:54:29 +000033#include "lldb/Target/DynamicLoader.h"
Andrew MacPherson17220c12014-03-05 10:12:43 +000034#include "lldb/Target/JITLoader.h"
Greg Clayton56d9a1b2011-08-22 02:49:39 +000035#include "lldb/Target/OperatingSystem.h"
Jim Ingham22777012010-09-23 02:01:19 +000036#include "lldb/Target/LanguageRuntime.h"
37#include "lldb/Target/CPPLanguageRuntime.h"
38#include "lldb/Target/ObjCLanguageRuntime.h"
Greg Claytone996fd32011-03-08 22:40:15 +000039#include "lldb/Target/Platform.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000040#include "lldb/Target/RegisterContext.h"
Greg Claytonf4b47e12010-08-04 01:40:35 +000041#include "lldb/Target/StopInfo.h"
Jason Molendaeef51062013-11-05 03:57:19 +000042#include "lldb/Target/SystemRuntime.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000043#include "lldb/Target/Target.h"
44#include "lldb/Target/TargetList.h"
45#include "lldb/Target/Thread.h"
46#include "lldb/Target/ThreadPlan.h"
Jim Ingham076b3042012-04-10 01:21:57 +000047#include "lldb/Target/ThreadPlanBase.h"
Jim Ingham1460e4b2014-01-10 23:46:59 +000048#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000049
Charles Davis510938e2013-08-27 05:04:57 +000050#ifndef LLDB_DISABLE_POSIX
51#include <spawn.h>
52#endif
53
Chris Lattner30fdc8d2010-06-08 16:52:24 +000054using namespace lldb;
55using namespace lldb_private;
56
Greg Clayton67cc0632012-08-22 17:17:09 +000057
58// Comment out line below to disable memory caching, overriding the process setting
59// target.process.disable-memory-cache
60#define ENABLE_MEMORY_CACHING
61
62#ifdef ENABLE_MEMORY_CACHING
63#define DISABLE_MEM_CACHE_DEFAULT false
64#else
65#define DISABLE_MEM_CACHE_DEFAULT true
66#endif
67
68class ProcessOptionValueProperties : public OptionValueProperties
69{
70public:
71 ProcessOptionValueProperties (const ConstString &name) :
72 OptionValueProperties (name)
73 {
74 }
75
76 // This constructor is used when creating ProcessOptionValueProperties when it
77 // is part of a new lldb_private::Process instance. It will copy all current
78 // global property values as needed
79 ProcessOptionValueProperties (ProcessProperties *global_properties) :
80 OptionValueProperties(*global_properties->GetValueProperties())
81 {
82 }
83
84 virtual const Property *
85 GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
86 {
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +000087 // When getting the value for a key from the process options, we will always
Greg Clayton67cc0632012-08-22 17:17:09 +000088 // try and grab the setting from the current process if there is one. Else we just
89 // use the one from this instance.
90 if (exe_ctx)
91 {
92 Process *process = exe_ctx->GetProcessPtr();
93 if (process)
94 {
95 ProcessOptionValueProperties *instance_properties = static_cast<ProcessOptionValueProperties *>(process->GetValueProperties().get());
96 if (this != instance_properties)
97 return instance_properties->ProtectedGetPropertyAtIndex (idx);
98 }
99 }
100 return ProtectedGetPropertyAtIndex (idx);
101 }
102};
103
104static PropertyDefinition
105g_properties[] =
106{
107 { "disable-memory-cache" , OptionValue::eTypeBoolean, false, DISABLE_MEM_CACHE_DEFAULT, NULL, NULL, "Disable reading and caching of memory in fixed-size units." },
Jim Ingham8c3f2762012-11-29 00:41:12 +0000108 { "extra-startup-command", OptionValue::eTypeArray , false, OptionValue::eTypeString, NULL, NULL, "A list containing extra commands understood by the particular process plugin used. "
109 "For instance, to turn on debugserver logging set this to \"QSetLogging:bitmask=LOG_DEFAULT;\"" },
Jim Inghamafc1b122013-01-31 19:48:57 +0000110 { "ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, breakpoints will be ignored during expression evaluation." },
111 { "unwind-on-error-in-expressions", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, errors in expression evaluation will unwind the stack back to the state before the call." },
Greg Claytone1e835c2012-11-29 18:48:47 +0000112 { "python-os-plugin-path", OptionValue::eTypeFileSpec, false, true, NULL, NULL, "A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class." },
Jim Ingham29950772013-01-26 02:19:28 +0000113 { "stop-on-sharedlibrary-events" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, stop when a shared library is loaded or unloaded." },
Jim Inghamacff8952013-05-02 00:27:30 +0000114 { "detach-keeps-stopped" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, detach will attempt to keep the process stopped." },
Greg Clayton67cc0632012-08-22 17:17:09 +0000115 { NULL , OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL }
116};
117
118enum {
119 ePropertyDisableMemCache,
Greg Claytonc9d645d2012-10-18 22:40:37 +0000120 ePropertyExtraStartCommand,
Jim Ingham184e9812013-01-15 02:47:48 +0000121 ePropertyIgnoreBreakpointsInExpressions,
122 ePropertyUnwindOnErrorInExpressions,
Jim Ingham29950772013-01-26 02:19:28 +0000123 ePropertyPythonOSPluginPath,
Jim Inghamacff8952013-05-02 00:27:30 +0000124 ePropertyStopOnSharedLibraryEvents,
125 ePropertyDetachKeepsStopped
Greg Clayton67cc0632012-08-22 17:17:09 +0000126};
127
128ProcessProperties::ProcessProperties (bool is_global) :
129 Properties ()
130{
131 if (is_global)
132 {
133 m_collection_sp.reset (new ProcessOptionValueProperties(ConstString("process")));
134 m_collection_sp->Initialize(g_properties);
135 m_collection_sp->AppendProperty(ConstString("thread"),
Jim Ingham29950772013-01-26 02:19:28 +0000136 ConstString("Settings specific to threads."),
Greg Clayton67cc0632012-08-22 17:17:09 +0000137 true,
138 Thread::GetGlobalProperties()->GetValueProperties());
139 }
140 else
141 m_collection_sp.reset (new ProcessOptionValueProperties(Process::GetGlobalProperties().get()));
142}
143
144ProcessProperties::~ProcessProperties()
145{
146}
147
148bool
149ProcessProperties::GetDisableMemoryCache() const
150{
151 const uint32_t idx = ePropertyDisableMemCache;
152 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
153}
154
155Args
156ProcessProperties::GetExtraStartupCommands () const
157{
158 Args args;
159 const uint32_t idx = ePropertyExtraStartCommand;
160 m_collection_sp->GetPropertyAtIndexAsArgs(NULL, idx, args);
161 return args;
162}
163
164void
165ProcessProperties::SetExtraStartupCommands (const Args &args)
166{
167 const uint32_t idx = ePropertyExtraStartCommand;
168 m_collection_sp->SetPropertyAtIndexFromArgs(NULL, idx, args);
169}
170
Greg Claytonc9d645d2012-10-18 22:40:37 +0000171FileSpec
172ProcessProperties::GetPythonOSPluginPath () const
173{
174 const uint32_t idx = ePropertyPythonOSPluginPath;
175 return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx);
176}
177
178void
179ProcessProperties::SetPythonOSPluginPath (const FileSpec &file)
180{
181 const uint32_t idx = ePropertyPythonOSPluginPath;
182 m_collection_sp->SetPropertyAtIndexAsFileSpec(NULL, idx, file);
183}
184
Jim Ingham184e9812013-01-15 02:47:48 +0000185
186bool
187ProcessProperties::GetIgnoreBreakpointsInExpressions () const
188{
189 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
190 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
191}
192
193void
194ProcessProperties::SetIgnoreBreakpointsInExpressions (bool ignore)
195{
196 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
197 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore);
198}
199
200bool
201ProcessProperties::GetUnwindOnErrorInExpressions () const
202{
203 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
204 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
205}
206
207void
208ProcessProperties::SetUnwindOnErrorInExpressions (bool ignore)
209{
210 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
211 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore);
212}
213
Jim Ingham29950772013-01-26 02:19:28 +0000214bool
215ProcessProperties::GetStopOnSharedLibraryEvents () const
216{
217 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
218 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
219}
220
221void
222ProcessProperties::SetStopOnSharedLibraryEvents (bool stop)
223{
224 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
225 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop);
226}
227
Jim Inghamacff8952013-05-02 00:27:30 +0000228bool
229ProcessProperties::GetDetachKeepsStopped () const
230{
231 const uint32_t idx = ePropertyDetachKeepsStopped;
232 return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
233}
234
235void
236ProcessProperties::SetDetachKeepsStopped (bool stop)
237{
238 const uint32_t idx = ePropertyDetachKeepsStopped;
239 m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop);
240}
241
Greg Clayton32e0a752011-03-30 18:16:51 +0000242void
Greg Clayton8b82f082011-04-12 05:54:46 +0000243ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000244{
245 const char *cstr;
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000246 if (m_pid != LLDB_INVALID_PROCESS_ID)
Daniel Malead01b2952012-11-29 21:49:15 +0000247 s.Printf (" pid = %" PRIu64 "\n", m_pid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000248
249 if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
Daniel Malead01b2952012-11-29 21:49:15 +0000250 s.Printf (" parent = %" PRIu64 "\n", m_parent_pid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000251
252 if (m_executable)
253 {
254 s.Printf (" name = %s\n", m_executable.GetFilename().GetCString());
255 s.PutCString (" file = ");
256 m_executable.Dump(&s);
257 s.EOL();
258 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000259 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000260 if (argc > 0)
261 {
262 for (uint32_t i=0; i<argc; i++)
263 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000264 const char *arg = m_arguments.GetArgumentAtIndex(i);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000265 if (i < 10)
Greg Clayton8b82f082011-04-12 05:54:46 +0000266 s.Printf (" arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000267 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000268 s.Printf ("arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000269 }
270 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000271
272 const uint32_t envc = m_environment.GetArgumentCount();
273 if (envc > 0)
274 {
275 for (uint32_t i=0; i<envc; i++)
276 {
277 const char *env = m_environment.GetArgumentAtIndex(i);
278 if (i < 10)
279 s.Printf (" env[%u] = %s\n", i, env);
280 else
281 s.Printf ("env[%u] = %s\n", i, env);
282 }
283 }
284
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000285 if (m_arch.IsValid())
286 s.Printf (" arch = %s\n", m_arch.GetTriple().str().c_str());
287
Greg Clayton8b82f082011-04-12 05:54:46 +0000288 if (m_uid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000289 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000290 cstr = platform->GetUserName (m_uid);
291 s.Printf (" uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000292 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000293 if (m_gid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000294 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000295 cstr = platform->GetGroupName (m_gid);
296 s.Printf (" gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000297 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000298 if (m_euid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000299 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000300 cstr = platform->GetUserName (m_euid);
301 s.Printf (" euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000302 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000303 if (m_egid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000304 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000305 cstr = platform->GetGroupName (m_egid);
306 s.Printf (" egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000307 }
308}
309
310void
Greg Clayton8b82f082011-04-12 05:54:46 +0000311ProcessInstanceInfo::DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose)
Greg Clayton32e0a752011-03-30 18:16:51 +0000312{
Greg Clayton8b82f082011-04-12 05:54:46 +0000313 const char *label;
314 if (show_args || verbose)
315 label = "ARGUMENTS";
316 else
317 label = "NAME";
318
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000319 if (verbose)
320 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000321 s.Printf ("PID PARENT USER GROUP EFF USER EFF GROUP TRIPLE %s\n", label);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000322 s.PutCString ("====== ====== ========== ========== ========== ========== ======================== ============================\n");
323 }
324 else
325 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000326 s.Printf ("PID PARENT USER ARCH %s\n", label);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000327 s.PutCString ("====== ====== ========== ======= ============================\n");
328 }
Greg Clayton32e0a752011-03-30 18:16:51 +0000329}
330
331void
Greg Clayton8b82f082011-04-12 05:54:46 +0000332ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000333{
334 if (m_pid != LLDB_INVALID_PROCESS_ID)
335 {
336 const char *cstr;
Daniel Malead01b2952012-11-29 21:49:15 +0000337 s.Printf ("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000338
Greg Clayton32e0a752011-03-30 18:16:51 +0000339
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000340 if (verbose)
341 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000342 cstr = platform->GetUserName (m_uid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000343 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
344 s.Printf ("%-10s ", cstr);
345 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000346 s.Printf ("%-10u ", m_uid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000347
Greg Clayton8b82f082011-04-12 05:54:46 +0000348 cstr = platform->GetGroupName (m_gid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000349 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
350 s.Printf ("%-10s ", cstr);
351 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000352 s.Printf ("%-10u ", m_gid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000353
Greg Clayton8b82f082011-04-12 05:54:46 +0000354 cstr = platform->GetUserName (m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000355 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
356 s.Printf ("%-10s ", cstr);
357 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000358 s.Printf ("%-10u ", m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000359
Greg Clayton8b82f082011-04-12 05:54:46 +0000360 cstr = platform->GetGroupName (m_egid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000361 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
362 s.Printf ("%-10s ", cstr);
363 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000364 s.Printf ("%-10u ", m_egid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000365 s.Printf ("%-24s ", m_arch.IsValid() ? m_arch.GetTriple().str().c_str() : "");
366 }
367 else
368 {
Jason Molendafd54b362011-09-20 21:44:10 +0000369 s.Printf ("%-10s %-7d %s ",
Greg Clayton8b82f082011-04-12 05:54:46 +0000370 platform->GetUserName (m_euid),
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000371 (int)m_arch.GetTriple().getArchName().size(),
372 m_arch.GetTriple().getArchName().data());
373 }
374
Greg Clayton8b82f082011-04-12 05:54:46 +0000375 if (verbose || show_args)
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000376 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000377 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000378 if (argc > 0)
379 {
380 for (uint32_t i=0; i<argc; i++)
381 {
382 if (i > 0)
383 s.PutChar (' ');
Greg Clayton8b82f082011-04-12 05:54:46 +0000384 s.PutCString (m_arguments.GetArgumentAtIndex(i));
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000385 }
386 }
387 }
388 else
389 {
390 s.PutCString (GetName());
391 }
392
393 s.EOL();
Greg Clayton32e0a752011-03-30 18:16:51 +0000394 }
395}
396
Greg Clayton8b82f082011-04-12 05:54:46 +0000397Error
Greg Claytonf6b8b582011-04-13 00:18:08 +0000398ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
Greg Clayton8b82f082011-04-12 05:54:46 +0000399{
400 Error error;
Greg Clayton3bcdfc02012-12-04 00:32:51 +0000401 const int short_option = m_getopt_table[option_idx].val;
Greg Clayton8b82f082011-04-12 05:54:46 +0000402
403 switch (short_option)
404 {
405 case 's': // Stop at program entry point
406 launch_info.GetFlags().Set (eLaunchFlagStopAtEntry);
407 break;
408
Greg Clayton8b82f082011-04-12 05:54:46 +0000409 case 'i': // STDIN for read only
410 {
411 ProcessLaunchInfo::FileAction action;
Greg Clayton9845a8d2012-03-06 04:01:04 +0000412 if (action.Open (STDIN_FILENO, option_arg, true, false))
Greg Clayton8b82f082011-04-12 05:54:46 +0000413 launch_info.AppendFileAction (action);
414 }
415 break;
416
417 case 'o': // Open STDOUT for write only
418 {
419 ProcessLaunchInfo::FileAction action;
Greg Clayton9845a8d2012-03-06 04:01:04 +0000420 if (action.Open (STDOUT_FILENO, option_arg, false, true))
421 launch_info.AppendFileAction (action);
422 }
423 break;
424
425 case 'e': // STDERR for write only
426 {
427 ProcessLaunchInfo::FileAction action;
428 if (action.Open (STDERR_FILENO, option_arg, false, true))
Greg Clayton8b82f082011-04-12 05:54:46 +0000429 launch_info.AppendFileAction (action);
430 }
431 break;
432
Greg Clayton9845a8d2012-03-06 04:01:04 +0000433
Greg Clayton8b82f082011-04-12 05:54:46 +0000434 case 'p': // Process plug-in name
435 launch_info.SetProcessPluginName (option_arg);
436 break;
437
438 case 'n': // Disable STDIO
439 {
440 ProcessLaunchInfo::FileAction action;
Greg Clayton9845a8d2012-03-06 04:01:04 +0000441 if (action.Open (STDIN_FILENO, "/dev/null", true, false))
Greg Clayton8b82f082011-04-12 05:54:46 +0000442 launch_info.AppendFileAction (action);
Greg Clayton9845a8d2012-03-06 04:01:04 +0000443 if (action.Open (STDOUT_FILENO, "/dev/null", false, true))
Greg Clayton8b82f082011-04-12 05:54:46 +0000444 launch_info.AppendFileAction (action);
Greg Clayton9845a8d2012-03-06 04:01:04 +0000445 if (action.Open (STDERR_FILENO, "/dev/null", false, true))
Greg Clayton8b82f082011-04-12 05:54:46 +0000446 launch_info.AppendFileAction (action);
447 }
448 break;
449
450 case 'w':
451 launch_info.SetWorkingDirectory (option_arg);
452 break;
453
454 case 't': // Open process in new terminal window
455 launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
456 break;
457
458 case 'a':
Greg Clayton70512312012-05-08 01:45:38 +0000459 if (!launch_info.GetArchitecture().SetTriple (option_arg, m_interpreter.GetPlatform(true).get()))
460 launch_info.GetArchitecture().SetTriple (option_arg);
Greg Clayton8b82f082011-04-12 05:54:46 +0000461 break;
462
463 case 'A':
464 launch_info.GetFlags().Set (eLaunchFlagDisableASLR);
465 break;
466
Greg Clayton982c9762011-11-03 21:22:33 +0000467 case 'c':
Greg Clayton144f3a92011-11-15 03:53:30 +0000468 if (option_arg && option_arg[0])
469 launch_info.SetShell (option_arg);
470 else
Ed Masteb8ca4a22013-09-03 23:04:53 +0000471 launch_info.SetShell (LLDB_DEFAULT_SHELL);
Greg Clayton982c9762011-11-03 21:22:33 +0000472 break;
473
Greg Clayton8b82f082011-04-12 05:54:46 +0000474 case 'v':
475 launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
476 break;
477
478 default:
Greg Clayton86edbf42011-10-26 00:56:27 +0000479 error.SetErrorStringWithFormat("unrecognized short option character '%c'", short_option);
Greg Clayton8b82f082011-04-12 05:54:46 +0000480 break;
481
482 }
483 return error;
484}
485
486OptionDefinition
487ProcessLaunchCommandOptions::g_option_table[] =
488{
Zachary Turnerd37221d2014-07-09 16:31:49 +0000489{ LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Stop at the entry point of the program when launching a process."},
490{ LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Disable address space layout randomization when launching a process."},
491{ LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
492{ LLDB_OPT_SET_ALL, false, "working-dir", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeDirectoryName, "Set the current working directory to <path> when running the inferior."},
493{ LLDB_OPT_SET_ALL, false, "arch", 'a', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous."},
494{ LLDB_OPT_SET_ALL, false, "environment", 'v', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeNone, "Specify an environment variable name/value string (--environment NAME=VALUE). Can be specified multiple times for subsequent environment entries."},
495{ LLDB_OPT_SET_ALL, false, "shell", 'c', OptionParser::eOptionalArgument, NULL, NULL, 0, eArgTypeFilename, "Run the process in a shell (not supported on all platforms)."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000496
Zachary Turnerd37221d2014-07-09 16:31:49 +0000497{ LLDB_OPT_SET_1 , false, "stdin", 'i', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename, "Redirect stdin for the process to <filename>."},
498{ LLDB_OPT_SET_1 , false, "stdout", 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename, "Redirect stdout for the process to <filename>."},
499{ LLDB_OPT_SET_1 , false, "stderr", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename, "Redirect stderr for the process to <filename>."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000500
Zachary Turnerd37221d2014-07-09 16:31:49 +0000501{ LLDB_OPT_SET_2 , false, "tty", 't', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000502
Zachary Turnerd37221d2014-07-09 16:31:49 +0000503{ LLDB_OPT_SET_3 , false, "no-stdio", 'n', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Do not set up for terminal I/O to go to running process."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000504
Zachary Turnerd37221d2014-07-09 16:31:49 +0000505{ 0 , false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
Greg Clayton8b82f082011-04-12 05:54:46 +0000506};
507
508
509
510bool
511ProcessInstanceInfoMatch::NameMatches (const char *process_name) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000512{
513 if (m_name_match_type == eNameMatchIgnore || process_name == NULL)
514 return true;
515 const char *match_name = m_match_info.GetName();
516 if (!match_name)
517 return true;
518
519 return lldb_private::NameMatches (process_name, m_name_match_type, match_name);
520}
521
522bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000523ProcessInstanceInfoMatch::Matches (const ProcessInstanceInfo &proc_info) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000524{
525 if (!NameMatches (proc_info.GetName()))
526 return false;
527
528 if (m_match_info.ProcessIDIsValid() &&
529 m_match_info.GetProcessID() != proc_info.GetProcessID())
530 return false;
531
532 if (m_match_info.ParentProcessIDIsValid() &&
533 m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
534 return false;
535
Greg Clayton8b82f082011-04-12 05:54:46 +0000536 if (m_match_info.UserIDIsValid () &&
537 m_match_info.GetUserID() != proc_info.GetUserID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000538 return false;
539
Greg Clayton8b82f082011-04-12 05:54:46 +0000540 if (m_match_info.GroupIDIsValid () &&
541 m_match_info.GetGroupID() != proc_info.GetGroupID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000542 return false;
543
544 if (m_match_info.EffectiveUserIDIsValid () &&
545 m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
546 return false;
547
548 if (m_match_info.EffectiveGroupIDIsValid () &&
549 m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
550 return false;
551
552 if (m_match_info.GetArchitecture().IsValid() &&
Sean Callananbf4b7be2012-12-13 22:07:14 +0000553 !m_match_info.GetArchitecture().IsCompatibleMatch(proc_info.GetArchitecture()))
Greg Clayton32e0a752011-03-30 18:16:51 +0000554 return false;
555 return true;
556}
557
558bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000559ProcessInstanceInfoMatch::MatchAllProcesses () const
Greg Clayton32e0a752011-03-30 18:16:51 +0000560{
561 if (m_name_match_type != eNameMatchIgnore)
562 return false;
563
564 if (m_match_info.ProcessIDIsValid())
565 return false;
566
567 if (m_match_info.ParentProcessIDIsValid())
568 return false;
569
Greg Clayton8b82f082011-04-12 05:54:46 +0000570 if (m_match_info.UserIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000571 return false;
572
Greg Clayton8b82f082011-04-12 05:54:46 +0000573 if (m_match_info.GroupIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000574 return false;
575
576 if (m_match_info.EffectiveUserIDIsValid ())
577 return false;
578
579 if (m_match_info.EffectiveGroupIDIsValid ())
580 return false;
581
582 if (m_match_info.GetArchitecture().IsValid())
583 return false;
584
585 if (m_match_all_users)
586 return false;
587
588 return true;
589
590}
591
592void
Greg Clayton8b82f082011-04-12 05:54:46 +0000593ProcessInstanceInfoMatch::Clear()
Greg Clayton32e0a752011-03-30 18:16:51 +0000594{
595 m_match_info.Clear();
596 m_name_match_type = eNameMatchIgnore;
597 m_match_all_users = false;
598}
Greg Clayton58be07b2011-01-07 06:08:19 +0000599
Greg Claytonc3776bf2012-02-09 06:16:32 +0000600ProcessSP
601Process::FindPlugin (Target &target, const char *plugin_name, Listener &listener, const FileSpec *crash_file_path)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000602{
Greg Clayton949e8222013-01-16 17:29:04 +0000603 static uint32_t g_process_unique_id = 0;
604
Greg Claytonc3776bf2012-02-09 06:16:32 +0000605 ProcessSP process_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000606 ProcessCreateInstance create_callback = NULL;
607 if (plugin_name)
608 {
Greg Clayton57abc5d2013-05-10 21:47:16 +0000609 ConstString const_plugin_name(plugin_name);
610 create_callback = PluginManager::GetProcessCreateCallbackForPluginName (const_plugin_name);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000611 if (create_callback)
612 {
Greg Claytonc3776bf2012-02-09 06:16:32 +0000613 process_sp = create_callback(target, listener, crash_file_path);
614 if (process_sp)
615 {
Greg Clayton949e8222013-01-16 17:29:04 +0000616 if (process_sp->CanDebug(target, true))
617 {
618 process_sp->m_process_unique_id = ++g_process_unique_id;
619 }
620 else
Greg Claytonc3776bf2012-02-09 06:16:32 +0000621 process_sp.reset();
622 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000623 }
624 }
625 else
626 {
Greg Claytonc982c762010-07-09 20:39:50 +0000627 for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000628 {
Greg Claytonc3776bf2012-02-09 06:16:32 +0000629 process_sp = create_callback(target, listener, crash_file_path);
630 if (process_sp)
631 {
Greg Clayton949e8222013-01-16 17:29:04 +0000632 if (process_sp->CanDebug(target, false))
633 {
634 process_sp->m_process_unique_id = ++g_process_unique_id;
Greg Claytonc3776bf2012-02-09 06:16:32 +0000635 break;
Greg Clayton949e8222013-01-16 17:29:04 +0000636 }
637 else
638 process_sp.reset();
Greg Claytonc3776bf2012-02-09 06:16:32 +0000639 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000640 }
641 }
Greg Claytonc3776bf2012-02-09 06:16:32 +0000642 return process_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000643}
644
Jim Ingham4bddaeb2012-02-16 06:50:00 +0000645ConstString &
646Process::GetStaticBroadcasterClass ()
647{
648 static ConstString class_name ("lldb.process");
649 return class_name;
650}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000651
652//----------------------------------------------------------------------
653// Process constructor
654//----------------------------------------------------------------------
655Process::Process(Target &target, Listener &listener) :
Greg Clayton67cc0632012-08-22 17:17:09 +0000656 ProcessProperties (false),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000657 UserID (LLDB_INVALID_PROCESS_ID),
Jim Ingham4bddaeb2012-02-16 06:50:00 +0000658 Broadcaster (&(target.GetDebugger()), "lldb.process"),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000659 m_target (target),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000660 m_public_state (eStateUnloaded),
661 m_private_state (eStateUnloaded),
Jim Ingham4bddaeb2012-02-16 06:50:00 +0000662 m_private_state_broadcaster (NULL, "lldb.process.internal_state_broadcaster"),
663 m_private_state_control_broadcaster (NULL, "lldb.process.internal_state_control_broadcaster"),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000664 m_private_state_listener ("lldb.process.internal_state_listener"),
665 m_private_state_control_wait(),
666 m_private_state_thread (LLDB_INVALID_HOST_THREAD),
Jim Ingham4b536182011-08-09 02:12:22 +0000667 m_mod_id (),
Greg Clayton949e8222013-01-16 17:29:04 +0000668 m_process_unique_id(0),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000669 m_thread_index_id (0),
Han Ming Ongc2c423e2013-01-08 22:10:01 +0000670 m_thread_id_to_index_id_map (),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000671 m_exit_status (-1),
672 m_exit_string (),
Andrew Kaylorba4e61d2013-05-07 18:35:34 +0000673 m_thread_mutex (Mutex::eMutexTypeRecursive),
674 m_thread_list_real (this),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000675 m_thread_list (this),
Jason Molenda864f1cc2013-11-11 05:20:44 +0000676 m_extended_thread_list (this),
Jason Molenda4ff13262013-11-20 00:31:38 +0000677 m_extended_thread_stop_id (0),
Jason Molenda5e8dce42013-12-13 00:29:16 +0000678 m_queue_list (this),
679 m_queue_list_stop_id (0),
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000680 m_notifications (),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000681 m_image_tokens (),
682 m_listener (listener),
683 m_breakpoint_site_list (),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000684 m_dynamic_checkers_ap (),
Caroline Ticeef5c6d02010-11-16 05:07:41 +0000685 m_unix_signals (),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000686 m_abi_sp (),
Caroline Ticeef5c6d02010-11-16 05:07:41 +0000687 m_process_input_reader (),
Greg Clayton3e06bd92011-01-09 21:07:35 +0000688 m_stdio_communication ("process.stdio"),
Greg Clayton3af9ea52010-11-18 05:57:03 +0000689 m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
Greg Clayton58be07b2011-01-07 06:08:19 +0000690 m_stdout_data (),
Greg Clayton93e86192011-11-13 04:45:22 +0000691 m_stderr_data (),
Han Ming Ongab3b8b22012-11-17 00:21:04 +0000692 m_profile_data_comm_mutex (Mutex::eMutexTypeRecursive),
693 m_profile_data (),
Greg Claytond495c532011-05-17 03:37:42 +0000694 m_memory_cache (*this),
695 m_allocated_memory_cache (*this),
Greg Claytone24c4ac2011-11-17 04:46:02 +0000696 m_should_detach (false),
Sean Callanan90539452011-09-20 23:01:51 +0000697 m_next_event_action_ap(),
Greg Clayton96249852013-04-18 16:57:27 +0000698 m_public_run_lock (),
Greg Clayton96249852013-04-18 16:57:27 +0000699 m_private_run_lock (),
Jim Inghamaacc3182012-06-06 00:29:30 +0000700 m_currently_handling_event(false),
Jim Ingham4fc6cb92012-08-22 21:34:33 +0000701 m_finalize_called(false),
Greg Claytonf9b57b92013-05-10 23:48:10 +0000702 m_clear_thread_plans_on_stop (false),
Jim Ingham1460e4b2014-01-10 23:46:59 +0000703 m_force_next_event_delivery(false),
Jim Ingham0161b492013-02-09 01:29:05 +0000704 m_last_broadcast_state (eStateInvalid),
Jason Molenda69b6b632013-03-05 03:33:59 +0000705 m_destroy_in_process (false),
706 m_can_jit(eCanJITDontKnow)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000707{
Jim Ingham4bddaeb2012-02-16 06:50:00 +0000708 CheckInWithManager ();
Caroline Tice1559a462010-09-27 00:30:10 +0000709
Greg Clayton5160ce52013-03-27 23:08:40 +0000710 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000711 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000712 log->Printf ("%p Process::Process()", static_cast<void*>(this));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000713
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000714 SetEventName (eBroadcastBitStateChanged, "state-changed");
715 SetEventName (eBroadcastBitInterrupt, "interrupt");
716 SetEventName (eBroadcastBitSTDOUT, "stdout-available");
717 SetEventName (eBroadcastBitSTDERR, "stderr-available");
Han Ming Ongab3b8b22012-11-17 00:21:04 +0000718 SetEventName (eBroadcastBitProfileData, "profile-data-available");
Greg Claytoncfd1ace2010-10-31 03:01:06 +0000719
Greg Clayton35a4cc52012-10-29 20:52:08 +0000720 m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlStop , "control-stop" );
721 m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlPause , "control-pause" );
722 m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlResume, "control-resume");
723
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000724 listener.StartListeningForEvents (this,
725 eBroadcastBitStateChanged |
726 eBroadcastBitInterrupt |
727 eBroadcastBitSTDOUT |
Han Ming Ongab3b8b22012-11-17 00:21:04 +0000728 eBroadcastBitSTDERR |
729 eBroadcastBitProfileData);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000730
731 m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster,
Jim Inghamcfc09352012-07-27 23:57:19 +0000732 eBroadcastBitStateChanged |
733 eBroadcastBitInterrupt);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000734
735 m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster,
736 eBroadcastInternalStateControlStop |
737 eBroadcastInternalStateControlPause |
738 eBroadcastInternalStateControlResume);
739}
740
741//----------------------------------------------------------------------
742// Destructor
743//----------------------------------------------------------------------
744Process::~Process()
745{
Greg Clayton5160ce52013-03-27 23:08:40 +0000746 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000747 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000748 log->Printf ("%p Process::~Process()", static_cast<void*>(this));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000749 StopPrivateStateThread();
750}
751
Greg Clayton67cc0632012-08-22 17:17:09 +0000752const ProcessPropertiesSP &
753Process::GetGlobalProperties()
754{
755 static ProcessPropertiesSP g_settings_sp;
756 if (!g_settings_sp)
757 g_settings_sp.reset (new ProcessProperties (true));
758 return g_settings_sp;
759}
760
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000761void
762Process::Finalize()
763{
Greg Claytone24c4ac2011-11-17 04:46:02 +0000764 switch (GetPrivateState())
765 {
766 case eStateConnected:
767 case eStateAttaching:
768 case eStateLaunching:
769 case eStateStopped:
770 case eStateRunning:
771 case eStateStepping:
772 case eStateCrashed:
773 case eStateSuspended:
774 if (GetShouldDetach())
Jim Inghamacff8952013-05-02 00:27:30 +0000775 {
776 // FIXME: This will have to be a process setting:
777 bool keep_stopped = false;
778 Detach(keep_stopped);
779 }
Greg Claytone24c4ac2011-11-17 04:46:02 +0000780 else
781 Destroy();
782 break;
783
784 case eStateInvalid:
785 case eStateUnloaded:
786 case eStateDetached:
787 case eStateExited:
788 break;
789 }
790
Greg Clayton1ed54f52011-10-01 00:45:15 +0000791 // Clear our broadcaster before we proceed with destroying
792 Broadcaster::Clear();
793
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000794 // Do any cleanup needed prior to being destructed... Subclasses
795 // that override this method should call this superclass method as well.
Jim Inghamd0a3e122011-02-16 17:54:55 +0000796
797 // We need to destroy the loader before the derived Process class gets destroyed
798 // since it is very likely that undoing the loader will require access to the real process.
Greg Clayton894f82f2012-01-20 23:08:34 +0000799 m_dynamic_checkers_ap.reset();
800 m_abi_sp.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000801 m_os_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +0000802 m_system_runtime_ap.reset();
Greg Clayton894f82f2012-01-20 23:08:34 +0000803 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +0000804 m_jit_loaders_ap.reset();
Andrew Kaylorba4e61d2013-05-07 18:35:34 +0000805 m_thread_list_real.Destroy();
Greg Claytone1cd1be2012-01-29 20:56:30 +0000806 m_thread_list.Destroy();
Jason Molenda864f1cc2013-11-11 05:20:44 +0000807 m_extended_thread_list.Destroy();
Jason Molenda5e8dce42013-12-13 00:29:16 +0000808 m_queue_list.Clear();
809 m_queue_list_stop_id = 0;
Greg Clayton894f82f2012-01-20 23:08:34 +0000810 std::vector<Notifications> empty_notifications;
811 m_notifications.swap(empty_notifications);
812 m_image_tokens.clear();
813 m_memory_cache.Clear();
814 m_allocated_memory_cache.Clear();
815 m_language_runtimes.clear();
816 m_next_event_action_ap.reset();
Greg Clayton35a4cc52012-10-29 20:52:08 +0000817//#ifdef LLDB_CONFIGURATION_DEBUG
818// StreamFile s(stdout, false);
819// EventSP event_sp;
820// while (m_private_state_listener.GetNextEvent(event_sp))
821// {
822// event_sp->Dump (&s);
823// s.EOL();
824// }
825//#endif
826 // We have to be very careful here as the m_private_state_listener might
827 // contain events that have ProcessSP values in them which can keep this
828 // process around forever. These events need to be cleared out.
829 m_private_state_listener.Clear();
Ed Maste64fad602013-07-29 20:58:06 +0000830 m_public_run_lock.TrySetRunning(); // This will do nothing if already locked
831 m_public_run_lock.SetStopped();
832 m_private_run_lock.TrySetRunning(); // This will do nothing if already locked
833 m_private_run_lock.SetStopped();
Jim Ingham4fc6cb92012-08-22 21:34:33 +0000834 m_finalize_called = true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000835}
836
837void
838Process::RegisterNotificationCallbacks (const Notifications& callbacks)
839{
840 m_notifications.push_back(callbacks);
841 if (callbacks.initialize != NULL)
842 callbacks.initialize (callbacks.baton, this);
843}
844
845bool
846Process::UnregisterNotificationCallbacks(const Notifications& callbacks)
847{
848 std::vector<Notifications>::iterator pos, end = m_notifications.end();
849 for (pos = m_notifications.begin(); pos != end; ++pos)
850 {
851 if (pos->baton == callbacks.baton &&
852 pos->initialize == callbacks.initialize &&
853 pos->process_state_changed == callbacks.process_state_changed)
854 {
855 m_notifications.erase(pos);
856 return true;
857 }
858 }
859 return false;
860}
861
862void
863Process::SynchronouslyNotifyStateChanged (StateType state)
864{
865 std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end();
866 for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos)
867 {
868 if (notification_pos->process_state_changed)
869 notification_pos->process_state_changed (notification_pos->baton, this, state);
870 }
871}
872
873// FIXME: We need to do some work on events before the general Listener sees them.
874// For instance if we are continuing from a breakpoint, we need to ensure that we do
875// the little "insert real insn, step & stop" trick. But we can't do that when the
876// event is delivered by the broadcaster - since that is done on the thread that is
877// waiting for new events, so if we needed more than one event for our handling, we would
878// stall. So instead we do it when we fetch the event off of the queue.
879//
880
881StateType
882Process::GetNextEvent (EventSP &event_sp)
883{
884 StateType state = eStateInvalid;
885
886 if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp)
887 state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
888
889 return state;
890}
891
892
893StateType
Greg Clayton44d93782014-01-27 23:43:24 +0000894Process::WaitForProcessToStop (const TimeValue *timeout, lldb::EventSP *event_sp_ptr, bool wait_always, Listener *hijack_listener)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000895{
Jim Ingham4b536182011-08-09 02:12:22 +0000896 // We can't just wait for a "stopped" event, because the stopped event may have restarted the target.
897 // We have to actually check each event, and in the case of a stopped event check the restarted flag
898 // on the event.
Greg Clayton85fb1b92012-09-11 02:33:37 +0000899 if (event_sp_ptr)
900 event_sp_ptr->reset();
Jim Ingham4b536182011-08-09 02:12:22 +0000901 StateType state = GetState();
902 // If we are exited or detached, we won't ever get back to any
903 // other valid state...
904 if (state == eStateDetached || state == eStateExited)
905 return state;
906
Daniel Malea9e9919f2013-10-09 16:56:28 +0000907 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
908 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000909 log->Printf ("Process::%s (timeout = %p)", __FUNCTION__,
910 static_cast<const void*>(timeout));
Daniel Malea9e9919f2013-10-09 16:56:28 +0000911
912 if (!wait_always &&
913 StateIsStoppedState(state, true) &&
914 StateIsStoppedState(GetPrivateState(), true)) {
915 if (log)
916 log->Printf("Process::%s returning without waiting for events; process private and public states are already 'stopped'.",
917 __FUNCTION__);
918 return state;
919 }
920
Jim Ingham4b536182011-08-09 02:12:22 +0000921 while (state != eStateInvalid)
922 {
Greg Clayton85fb1b92012-09-11 02:33:37 +0000923 EventSP event_sp;
Greg Clayton44d93782014-01-27 23:43:24 +0000924 state = WaitForStateChangedEvents (timeout, event_sp, hijack_listener);
Greg Clayton85fb1b92012-09-11 02:33:37 +0000925 if (event_sp_ptr && event_sp)
926 *event_sp_ptr = event_sp;
927
Jim Ingham4b536182011-08-09 02:12:22 +0000928 switch (state)
929 {
930 case eStateCrashed:
931 case eStateDetached:
932 case eStateExited:
933 case eStateUnloaded:
Greg Clayton44d93782014-01-27 23:43:24 +0000934 // We need to toggle the run lock as this won't get done in
935 // SetPublicState() if the process is hijacked.
936 if (hijack_listener)
937 m_public_run_lock.SetStopped();
Jim Ingham4b536182011-08-09 02:12:22 +0000938 return state;
939 case eStateStopped:
940 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
941 continue;
942 else
Greg Clayton44d93782014-01-27 23:43:24 +0000943 {
944 // We need to toggle the run lock as this won't get done in
945 // SetPublicState() if the process is hijacked.
946 if (hijack_listener)
947 m_public_run_lock.SetStopped();
Jim Ingham4b536182011-08-09 02:12:22 +0000948 return state;
Greg Clayton44d93782014-01-27 23:43:24 +0000949 }
Jim Ingham4b536182011-08-09 02:12:22 +0000950 default:
951 continue;
952 }
953 }
954 return state;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000955}
956
957
958StateType
959Process::WaitForState
960(
961 const TimeValue *timeout,
Greg Clayton44d93782014-01-27 23:43:24 +0000962 const StateType *match_states,
963 const uint32_t num_match_states
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000964)
965{
966 EventSP event_sp;
967 uint32_t i;
Greg Clayton05faeb72010-10-07 04:19:01 +0000968 StateType state = GetState();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000969 while (state != eStateInvalid)
970 {
Greg Clayton05faeb72010-10-07 04:19:01 +0000971 // If we are exited or detached, we won't ever get back to any
972 // other valid state...
973 if (state == eStateDetached || state == eStateExited)
974 return state;
975
Greg Clayton44d93782014-01-27 23:43:24 +0000976 state = WaitForStateChangedEvents (timeout, event_sp, NULL);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000977
978 for (i=0; i<num_match_states; ++i)
979 {
980 if (match_states[i] == state)
981 return state;
982 }
983 }
984 return state;
985}
986
Jim Ingham30f9b212010-10-11 23:53:14 +0000987bool
988Process::HijackProcessEvents (Listener *listener)
989{
990 if (listener != NULL)
991 {
Jim Inghamcfc09352012-07-27 23:57:19 +0000992 return HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt);
Jim Ingham30f9b212010-10-11 23:53:14 +0000993 }
994 else
995 return false;
996}
997
998void
999Process::RestoreProcessEvents ()
1000{
1001 RestoreBroadcaster();
1002}
1003
Jim Ingham0f16e732011-02-08 05:20:59 +00001004bool
1005Process::HijackPrivateProcessEvents (Listener *listener)
1006{
1007 if (listener != NULL)
1008 {
Jim Inghamcfc09352012-07-27 23:57:19 +00001009 return m_private_state_broadcaster.HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt);
Jim Ingham0f16e732011-02-08 05:20:59 +00001010 }
1011 else
1012 return false;
1013}
1014
1015void
1016Process::RestorePrivateProcessEvents ()
1017{
1018 m_private_state_broadcaster.RestoreBroadcaster();
1019}
1020
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001021StateType
Greg Clayton44d93782014-01-27 23:43:24 +00001022Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp, Listener *hijack_listener)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001023{
Greg Clayton5160ce52013-03-27 23:08:40 +00001024 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001025
1026 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001027 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1028 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001029
Greg Clayton44d93782014-01-27 23:43:24 +00001030 Listener *listener = hijack_listener;
1031 if (listener == NULL)
1032 listener = &m_listener;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001033
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001034 StateType state = eStateInvalid;
Greg Clayton44d93782014-01-27 23:43:24 +00001035 if (listener->WaitForEventForBroadcasterWithType (timeout,
1036 this,
1037 eBroadcastBitStateChanged | eBroadcastBitInterrupt,
1038 event_sp))
Jim Inghamcfc09352012-07-27 23:57:19 +00001039 {
1040 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1041 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1042 else if (log)
1043 log->Printf ("Process::%s got no event or was interrupted.", __FUNCTION__);
1044 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001045
1046 if (log)
1047 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001048 __FUNCTION__, static_cast<const void*>(timeout),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001049 StateAsCString(state));
1050 return state;
1051}
1052
1053Event *
1054Process::PeekAtStateChangedEvents ()
1055{
Greg Clayton5160ce52013-03-27 23:08:40 +00001056 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001057
1058 if (log)
1059 log->Printf ("Process::%s...", __FUNCTION__);
1060
1061 Event *event_ptr;
Greg Clayton3fcbed62010-10-19 03:25:40 +00001062 event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this,
1063 eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001064 if (log)
1065 {
1066 if (event_ptr)
1067 {
1068 log->Printf ("Process::%s (event_ptr) => %s",
1069 __FUNCTION__,
1070 StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr)));
1071 }
1072 else
1073 {
1074 log->Printf ("Process::%s no events found",
1075 __FUNCTION__);
1076 }
1077 }
1078 return event_ptr;
1079}
1080
1081StateType
1082Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp)
1083{
Greg Clayton5160ce52013-03-27 23:08:40 +00001084 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001085
1086 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001087 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1088 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001089
1090 StateType state = eStateInvalid;
Greg Clayton6779606a2011-01-22 23:43:18 +00001091 if (m_private_state_listener.WaitForEventForBroadcasterWithType (timeout,
1092 &m_private_state_broadcaster,
Jim Inghamcfc09352012-07-27 23:57:19 +00001093 eBroadcastBitStateChanged | eBroadcastBitInterrupt,
Greg Clayton6779606a2011-01-22 23:43:18 +00001094 event_sp))
Jim Inghamcfc09352012-07-27 23:57:19 +00001095 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1096 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001097
1098 // This is a bit of a hack, but when we wait here we could very well return
1099 // to the command-line, and that could disable the log, which would render the
1100 // log we got above invalid.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001101 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001102 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
1103 __FUNCTION__, static_cast<const void *>(timeout),
1104 state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001105 return state;
1106}
1107
1108bool
1109Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only)
1110{
Greg Clayton5160ce52013-03-27 23:08:40 +00001111 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001112
1113 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001114 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1115 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001116
1117 if (control_only)
1118 return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp);
1119 else
1120 return m_private_state_listener.WaitForEvent(timeout, event_sp);
1121}
1122
1123bool
1124Process::IsRunning () const
1125{
1126 return StateIsRunningState (m_public_state.GetValue());
1127}
1128
1129int
1130Process::GetExitStatus ()
1131{
1132 if (m_public_state.GetValue() == eStateExited)
1133 return m_exit_status;
1134 return -1;
1135}
1136
Greg Clayton85851dd2010-12-04 00:10:17 +00001137
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001138const char *
1139Process::GetExitDescription ()
1140{
1141 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
1142 return m_exit_string.c_str();
1143 return NULL;
1144}
1145
Greg Clayton6779606a2011-01-22 23:43:18 +00001146bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001147Process::SetExitStatus (int status, const char *cstr)
1148{
Greg Clayton5160ce52013-03-27 23:08:40 +00001149 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Greg Clayton414f5d32011-01-25 02:58:48 +00001150 if (log)
1151 log->Printf("Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1152 status, status,
1153 cstr ? "\"" : "",
1154 cstr ? cstr : "NULL",
1155 cstr ? "\"" : "");
1156
Greg Clayton6779606a2011-01-22 23:43:18 +00001157 // We were already in the exited state
1158 if (m_private_state.GetValue() == eStateExited)
Greg Clayton414f5d32011-01-25 02:58:48 +00001159 {
Greg Clayton385d6032011-01-26 23:47:29 +00001160 if (log)
1161 log->Printf("Process::SetExitStatus () ignoring exit status because state was already set to eStateExited");
Greg Clayton6779606a2011-01-22 23:43:18 +00001162 return false;
Greg Clayton414f5d32011-01-25 02:58:48 +00001163 }
Greg Clayton6779606a2011-01-22 23:43:18 +00001164
1165 m_exit_status = status;
1166 if (cstr)
1167 m_exit_string = cstr;
1168 else
1169 m_exit_string.clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001170
Greg Clayton6779606a2011-01-22 23:43:18 +00001171 DidExit ();
Greg Clayton10177aa2010-12-08 05:08:21 +00001172
Greg Clayton6779606a2011-01-22 23:43:18 +00001173 SetPrivateState (eStateExited);
1174 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001175}
1176
1177// This static callback can be used to watch for local child processes on
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00001178// the current host. The child process exits, the process will be
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001179// found in the global target list (we want to be completely sure that the
1180// lldb_private::Process doesn't go away before we can deliver the signal.
1181bool
Greg Claytone4e45922011-11-16 05:37:56 +00001182Process::SetProcessExitStatus (void *callback_baton,
1183 lldb::pid_t pid,
1184 bool exited,
1185 int signo, // Zero for no signal
1186 int exit_status // Exit value of process if signal is zero
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001187)
1188{
Greg Clayton5160ce52013-03-27 23:08:40 +00001189 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytone4e45922011-11-16 05:37:56 +00001190 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001191 log->Printf ("Process::SetProcessExitStatus (baton=%p, pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n",
Greg Claytone4e45922011-11-16 05:37:56 +00001192 callback_baton,
1193 pid,
1194 exited,
1195 signo,
1196 exit_status);
1197
1198 if (exited)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001199 {
Greg Clayton66111032010-06-23 01:19:29 +00001200 TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001201 if (target_sp)
1202 {
1203 ProcessSP process_sp (target_sp->GetProcessSP());
1204 if (process_sp)
1205 {
1206 const char *signal_cstr = NULL;
1207 if (signo)
1208 signal_cstr = process_sp->GetUnixSignals().GetSignalAsCString (signo);
1209
1210 process_sp->SetExitStatus (exit_status, signal_cstr);
1211 }
1212 }
1213 return true;
1214 }
1215 return false;
1216}
1217
1218
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001219void
1220Process::UpdateThreadListIfNeeded ()
1221{
1222 const uint32_t stop_id = GetStopID();
1223 if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID())
1224 {
Greg Clayton2637f822011-11-17 01:23:07 +00001225 const StateType state = GetPrivateState();
1226 if (StateIsStoppedState (state, true))
1227 {
1228 Mutex::Locker locker (m_thread_list.GetMutex ());
Greg Claytone24c4ac2011-11-17 04:46:02 +00001229 // m_thread_list does have its own mutex, but we need to
1230 // hold onto the mutex between the call to UpdateThreadList(...)
1231 // and the os->UpdateThreadList(...) so it doesn't change on us
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001232 ThreadList &old_thread_list = m_thread_list;
1233 ThreadList real_thread_list(this);
Greg Clayton2637f822011-11-17 01:23:07 +00001234 ThreadList new_thread_list(this);
1235 // Always update the thread list with the protocol specific
Greg Clayton9fc13552012-04-10 00:18:59 +00001236 // thread list, but only update if "true" is returned
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001237 if (UpdateThreadList (m_thread_list_real, real_thread_list))
Greg Clayton9fc13552012-04-10 00:18:59 +00001238 {
Jim Ingham09437922013-03-01 20:04:25 +00001239 // Don't call into the OperatingSystem to update the thread list if we are shutting down, since
1240 // that may call back into the SBAPI's, requiring the API lock which is already held by whoever is
1241 // shutting us down, causing a deadlock.
1242 if (!m_destroy_in_process)
1243 {
1244 OperatingSystem *os = GetOperatingSystem ();
1245 if (os)
Greg Claytonb3ae8762013-04-12 20:07:46 +00001246 {
1247 // Clear any old backing threads where memory threads might have been
1248 // backed by actual threads from the lldb_private::Process subclass
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001249 size_t num_old_threads = old_thread_list.GetSize(false);
Greg Claytonb3ae8762013-04-12 20:07:46 +00001250 for (size_t i=0; i<num_old_threads; ++i)
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001251 old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
Greg Claytonb3ae8762013-04-12 20:07:46 +00001252
1253 // Now let the OperatingSystem plug-in update the thread list
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001254 os->UpdateThreadList (old_thread_list, // Old list full of threads created by OS plug-in
1255 real_thread_list, // The actual thread list full of threads created by each lldb_private::Process subclass
1256 new_thread_list); // The new thread list that we will show to the user that gets filled in
Greg Claytonb3ae8762013-04-12 20:07:46 +00001257 }
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001258 else
1259 {
1260 // No OS plug-in, the new thread list is the same as the real thread list
1261 new_thread_list = real_thread_list;
1262 }
Jim Ingham09437922013-03-01 20:04:25 +00001263 }
Jim Ingham02ff8e02013-06-22 00:55:02 +00001264
1265 m_thread_list_real.Update(real_thread_list);
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001266 m_thread_list.Update (new_thread_list);
1267 m_thread_list.SetStopID (stop_id);
Jason Molendaa6e91302013-11-19 05:44:41 +00001268
Jason Molenda4ff13262013-11-20 00:31:38 +00001269 if (GetLastNaturalStopID () != m_extended_thread_stop_id)
1270 {
1271 // Clear any extended threads that we may have accumulated previously
1272 m_extended_thread_list.Clear();
1273 m_extended_thread_stop_id = GetLastNaturalStopID ();
Jason Molenda5e8dce42013-12-13 00:29:16 +00001274
1275 m_queue_list.Clear();
1276 m_queue_list_stop_id = GetLastNaturalStopID ();
Jason Molenda4ff13262013-11-20 00:31:38 +00001277 }
Greg Clayton9fc13552012-04-10 00:18:59 +00001278 }
Greg Clayton2637f822011-11-17 01:23:07 +00001279 }
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001280 }
1281}
1282
Jason Molenda5e8dce42013-12-13 00:29:16 +00001283void
1284Process::UpdateQueueListIfNeeded ()
1285{
1286 if (m_system_runtime_ap.get())
1287 {
1288 if (m_queue_list.GetSize() == 0 || m_queue_list_stop_id != GetLastNaturalStopID())
1289 {
1290 const StateType state = GetPrivateState();
1291 if (StateIsStoppedState (state, true))
1292 {
1293 m_system_runtime_ap->PopulateQueueList (m_queue_list);
1294 m_queue_list_stop_id = GetLastNaturalStopID();
1295 }
1296 }
1297 }
1298}
1299
Greg Claytona4d87472013-01-18 23:41:08 +00001300ThreadSP
1301Process::CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context)
1302{
1303 OperatingSystem *os = GetOperatingSystem ();
1304 if (os)
1305 return os->CreateThread(tid, context);
1306 return ThreadSP();
1307}
1308
Han Ming Ongc2c423e2013-01-08 22:10:01 +00001309uint32_t
1310Process::GetNextThreadIndexID (uint64_t thread_id)
1311{
1312 return AssignIndexIDToThread(thread_id);
1313}
1314
1315bool
1316Process::HasAssignedIndexIDToThread(uint64_t thread_id)
1317{
1318 std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
1319 if (iterator == m_thread_id_to_index_id_map.end())
1320 {
1321 return false;
1322 }
1323 else
1324 {
1325 return true;
1326 }
1327}
1328
1329uint32_t
1330Process::AssignIndexIDToThread(uint64_t thread_id)
1331{
1332 uint32_t result = 0;
1333 std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
1334 if (iterator == m_thread_id_to_index_id_map.end())
1335 {
1336 result = ++m_thread_index_id;
1337 m_thread_id_to_index_id_map[thread_id] = result;
1338 }
1339 else
1340 {
1341 result = iterator->second;
1342 }
1343
1344 return result;
1345}
1346
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001347StateType
1348Process::GetState()
1349{
1350 // If any other threads access this we will need a mutex for it
1351 return m_public_state.GetValue ();
1352}
1353
1354void
Jim Ingham221d51c2013-05-08 00:35:16 +00001355Process::SetPublicState (StateType new_state, bool restarted)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001356{
Greg Clayton5160ce52013-03-27 23:08:40 +00001357 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001358 if (log)
Jim Ingham221d51c2013-05-08 00:35:16 +00001359 log->Printf("Process::SetPublicState (state = %s, restarted = %i)", StateAsCString(new_state), restarted);
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001360 const StateType old_state = m_public_state.GetValue();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001361 m_public_state.SetValue (new_state);
Jim Ingham3b8285d2012-04-19 01:40:33 +00001362
1363 // On the transition from Run to Stopped, we unlock the writer end of the
1364 // run lock. The lock gets locked in Resume, which is the public API
1365 // to tell the program to run.
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001366 if (!IsHijackedForEvent(eBroadcastBitStateChanged))
1367 {
Sean Callanan8b0737f2012-06-02 01:16:20 +00001368 if (new_state == eStateDetached)
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001369 {
Sean Callanan8b0737f2012-06-02 01:16:20 +00001370 if (log)
1371 log->Printf("Process::SetPublicState (%s) -- unlocking run lock for detach", StateAsCString(new_state));
Ed Maste64fad602013-07-29 20:58:06 +00001372 m_public_run_lock.SetStopped();
Sean Callanan8b0737f2012-06-02 01:16:20 +00001373 }
1374 else
1375 {
1376 const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1377 const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
Jim Ingham221d51c2013-05-08 00:35:16 +00001378 if ((old_state_is_stopped != new_state_is_stopped))
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001379 {
Jim Ingham221d51c2013-05-08 00:35:16 +00001380 if (new_state_is_stopped && !restarted)
Sean Callanan8b0737f2012-06-02 01:16:20 +00001381 {
1382 if (log)
1383 log->Printf("Process::SetPublicState (%s) -- unlocking run lock", StateAsCString(new_state));
Ed Maste64fad602013-07-29 20:58:06 +00001384 m_public_run_lock.SetStopped();
Sean Callanan8b0737f2012-06-02 01:16:20 +00001385 }
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001386 }
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001387 }
1388 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001389}
1390
Jim Ingham3b8285d2012-04-19 01:40:33 +00001391Error
1392Process::Resume ()
1393{
Greg Clayton5160ce52013-03-27 23:08:40 +00001394 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Jim Ingham3b8285d2012-04-19 01:40:33 +00001395 if (log)
1396 log->Printf("Process::Resume -- locking run lock");
Ed Maste64fad602013-07-29 20:58:06 +00001397 if (!m_public_run_lock.TrySetRunning())
Jim Ingham3b8285d2012-04-19 01:40:33 +00001398 {
1399 Error error("Resume request failed - process still running.");
1400 if (log)
Ed Maste64fad602013-07-29 20:58:06 +00001401 log->Printf ("Process::Resume: -- TrySetRunning failed, not resuming.");
Jim Ingham3b8285d2012-04-19 01:40:33 +00001402 return error;
1403 }
1404 return PrivateResume();
1405}
1406
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001407StateType
1408Process::GetPrivateState ()
1409{
1410 return m_private_state.GetValue();
1411}
1412
1413void
1414Process::SetPrivateState (StateType new_state)
1415{
Greg Claytonfb8b37a2014-07-14 23:09:29 +00001416 if (m_finalize_called)
1417 return;
1418
Greg Clayton5160ce52013-03-27 23:08:40 +00001419 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001420 bool state_changed = false;
1421
1422 if (log)
1423 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
1424
Andrew Kaylor29d65742013-05-10 17:19:04 +00001425 Mutex::Locker thread_locker(m_thread_list.GetMutex());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001426 Mutex::Locker locker(m_private_state.GetMutex());
1427
1428 const StateType old_state = m_private_state.GetValueNoLock ();
1429 state_changed = old_state != new_state;
Ed Mastec29693f2013-07-02 16:35:47 +00001430
Greg Claytonaa49c832013-05-03 22:25:56 +00001431 const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1432 const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1433 if (old_state_is_stopped != new_state_is_stopped)
1434 {
1435 if (new_state_is_stopped)
Ed Maste64fad602013-07-29 20:58:06 +00001436 m_private_run_lock.SetStopped();
Greg Claytonaa49c832013-05-03 22:25:56 +00001437 else
Ed Maste64fad602013-07-29 20:58:06 +00001438 m_private_run_lock.SetRunning();
Greg Claytonaa49c832013-05-03 22:25:56 +00001439 }
Andrew Kaylor93132f52013-05-28 23:04:25 +00001440
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001441 if (state_changed)
1442 {
1443 m_private_state.SetValueNoLock (new_state);
Greg Clayton2637f822011-11-17 01:23:07 +00001444 if (StateIsStoppedState(new_state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001445 {
Andrew Kaylor29d65742013-05-10 17:19:04 +00001446 // Note, this currently assumes that all threads in the list
1447 // stop when the process stops. In the future we will want to
1448 // support a debugging model where some threads continue to run
1449 // while others are stopped. When that happens we will either need
1450 // a way for the thread list to identify which threads are stopping
1451 // or create a special thread list containing only threads which
1452 // actually stopped.
1453 //
1454 // The process plugin is responsible for managing the actual
1455 // behavior of the threads and should have stopped any threads
1456 // that are going to stop before we get here.
1457 m_thread_list.DidStop();
1458
Jim Ingham4b536182011-08-09 02:12:22 +00001459 m_mod_id.BumpStopID();
Greg Clayton58be07b2011-01-07 06:08:19 +00001460 m_memory_cache.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001461 if (log)
Jim Ingham4b536182011-08-09 02:12:22 +00001462 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_mod_id.GetStopID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001463 }
1464 // Use our target to get a shared pointer to ourselves...
Greg Clayton35a4cc52012-10-29 20:52:08 +00001465 if (m_finalize_called && PrivateStateThreadIsValid() == false)
1466 BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state));
1467 else
1468 m_private_state_broadcaster.BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001469 }
1470 else
1471 {
1472 if (log)
Jason Molendafd54b362011-09-20 21:44:10 +00001473 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001474 }
1475}
1476
Jim Ingham0faa43f2011-11-08 03:00:11 +00001477void
1478Process::SetRunningUserExpression (bool on)
1479{
1480 m_mod_id.SetRunningUserExpression (on);
1481}
1482
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001483addr_t
1484Process::GetImageInfoAddress()
1485{
1486 return LLDB_INVALID_ADDRESS;
1487}
1488
Greg Clayton8f343b02010-11-04 01:54:29 +00001489//----------------------------------------------------------------------
1490// LoadImage
1491//
1492// This function provides a default implementation that works for most
1493// unix variants. Any Process subclasses that need to do shared library
1494// loading differently should override LoadImage and UnloadImage and
1495// do what is needed.
1496//----------------------------------------------------------------------
1497uint32_t
1498Process::LoadImage (const FileSpec &image_spec, Error &error)
1499{
Greg Claytonac7a3db2012-04-18 00:05:19 +00001500 char path[PATH_MAX];
1501 image_spec.GetPath(path, sizeof(path));
1502
Greg Clayton8f343b02010-11-04 01:54:29 +00001503 DynamicLoader *loader = GetDynamicLoader();
1504 if (loader)
1505 {
1506 error = loader->CanLoadImage();
1507 if (error.Fail())
1508 return LLDB_INVALID_IMAGE_TOKEN;
1509 }
1510
1511 if (error.Success())
1512 {
1513 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001514
1515 if (thread_sp)
1516 {
Jason Molendab57e4a12013-11-04 09:33:30 +00001517 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
Greg Clayton8f343b02010-11-04 01:54:29 +00001518
1519 if (frame_sp)
1520 {
1521 ExecutionContext exe_ctx;
1522 frame_sp->CalculateExecutionContext (exe_ctx);
Greg Clayton62afb9f2013-11-04 19:35:17 +00001523 EvaluateExpressionOptions expr_options;
1524 expr_options.SetUnwindOnError(true);
1525 expr_options.SetIgnoreBreakpoints(true);
1526 expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
Greg Clayton8f343b02010-11-04 01:54:29 +00001527 StreamString expr;
Greg Clayton8f343b02010-11-04 01:54:29 +00001528 expr.Printf("dlopen (\"%s\", 2)", path);
1529 const char *prefix = "extern \"C\" void* dlopen (const char *path, int mode);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001530 lldb::ValueObjectSP result_valobj_sp;
Greg Clayton62afb9f2013-11-04 19:35:17 +00001531 Error expr_error;
Greg Clayton26ab83d2012-10-31 20:49:04 +00001532 ClangUserExpression::Evaluate (exe_ctx,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001533 expr_options,
Greg Clayton26ab83d2012-10-31 20:49:04 +00001534 expr.GetData(),
1535 prefix,
1536 result_valobj_sp,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001537 expr_error);
1538 if (expr_error.Success())
Greg Clayton8f343b02010-11-04 01:54:29 +00001539 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001540 error = result_valobj_sp->GetError();
1541 if (error.Success())
Greg Clayton8f343b02010-11-04 01:54:29 +00001542 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001543 Scalar scalar;
1544 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001545 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001546 addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1547 if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
1548 {
1549 uint32_t image_token = m_image_tokens.size();
1550 m_image_tokens.push_back (image_ptr);
1551 return image_token;
1552 }
Jim Ingham3ac7cf32014-07-17 18:55:25 +00001553 else if (image_ptr == 0)
1554 {
1555 prefix = "extern \"C\" const char *dlerror(void);\n";
1556 expr.Clear();
1557 expr.PutCString("dlerror()");
1558 ClangUserExpression::Evaluate (exe_ctx,
1559 expr_options,
1560 expr.GetData(),
1561 prefix,
1562 result_valobj_sp,
1563 expr_error);
1564 if (result_valobj_sp && error.Success())
1565 {
1566 if (result_valobj_sp->IsCStringContainer(true))
1567 {
1568 lldb::DataBufferSP buf_sp (new DataBufferHeap());
1569 size_t num_chars = result_valobj_sp->ReadPointedString (buf_sp, error);
1570 if (error.Success() && num_chars > 0)
1571 {
1572 error.Clear();
1573 error.SetErrorStringWithFormat("dlopen failed: %s", buf_sp->GetBytes());
1574 }
1575 }
1576 }
1577 }
Greg Clayton8f343b02010-11-04 01:54:29 +00001578 }
1579 }
1580 }
Jim Ingham6c9ed912014-04-03 01:26:14 +00001581 else
1582 error = expr_error;
Greg Clayton8f343b02010-11-04 01:54:29 +00001583 }
1584 }
1585 }
Greg Claytonac7a3db2012-04-18 00:05:19 +00001586 if (!error.AsCString())
1587 error.SetErrorStringWithFormat("unable to load '%s'", path);
Greg Clayton8f343b02010-11-04 01:54:29 +00001588 return LLDB_INVALID_IMAGE_TOKEN;
1589}
1590
1591//----------------------------------------------------------------------
1592// UnloadImage
1593//
1594// This function provides a default implementation that works for most
1595// unix variants. Any Process subclasses that need to do shared library
1596// loading differently should override LoadImage and UnloadImage and
1597// do what is needed.
1598//----------------------------------------------------------------------
1599Error
1600Process::UnloadImage (uint32_t image_token)
1601{
1602 Error error;
1603 if (image_token < m_image_tokens.size())
1604 {
1605 const addr_t image_addr = m_image_tokens[image_token];
1606 if (image_addr == LLDB_INVALID_ADDRESS)
1607 {
1608 error.SetErrorString("image already unloaded");
1609 }
1610 else
1611 {
1612 DynamicLoader *loader = GetDynamicLoader();
1613 if (loader)
1614 error = loader->CanLoadImage();
1615
1616 if (error.Success())
1617 {
1618 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001619
1620 if (thread_sp)
1621 {
Jason Molendab57e4a12013-11-04 09:33:30 +00001622 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
Greg Clayton8f343b02010-11-04 01:54:29 +00001623
1624 if (frame_sp)
1625 {
1626 ExecutionContext exe_ctx;
1627 frame_sp->CalculateExecutionContext (exe_ctx);
Greg Clayton62afb9f2013-11-04 19:35:17 +00001628 EvaluateExpressionOptions expr_options;
1629 expr_options.SetUnwindOnError(true);
1630 expr_options.SetIgnoreBreakpoints(true);
1631 expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
Greg Clayton8f343b02010-11-04 01:54:29 +00001632 StreamString expr;
Daniel Malead01b2952012-11-29 21:49:15 +00001633 expr.Printf("dlclose ((void *)0x%" PRIx64 ")", image_addr);
Greg Clayton8f343b02010-11-04 01:54:29 +00001634 const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001635 lldb::ValueObjectSP result_valobj_sp;
Greg Clayton62afb9f2013-11-04 19:35:17 +00001636 Error expr_error;
Greg Clayton26ab83d2012-10-31 20:49:04 +00001637 ClangUserExpression::Evaluate (exe_ctx,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001638 expr_options,
Greg Clayton26ab83d2012-10-31 20:49:04 +00001639 expr.GetData(),
1640 prefix,
1641 result_valobj_sp,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001642 expr_error);
Greg Clayton8f343b02010-11-04 01:54:29 +00001643 if (result_valobj_sp->GetError().Success())
1644 {
1645 Scalar scalar;
Jim Ingham6035b672011-03-31 00:19:25 +00001646 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001647 {
1648 if (scalar.UInt(1))
1649 {
1650 error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData());
1651 }
1652 else
1653 {
1654 m_image_tokens[image_token] = LLDB_INVALID_ADDRESS;
1655 }
1656 }
1657 }
1658 else
1659 {
1660 error = result_valobj_sp->GetError();
1661 }
1662 }
1663 }
1664 }
1665 }
1666 }
1667 else
1668 {
1669 error.SetErrorString("invalid image token");
1670 }
1671 return error;
1672}
1673
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001674const lldb::ABISP &
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001675Process::GetABI()
1676{
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001677 if (!m_abi_sp)
1678 m_abi_sp = ABI::FindPlugin(m_target.GetArchitecture());
1679 return m_abi_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001680}
1681
Jim Ingham22777012010-09-23 02:01:19 +00001682LanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001683Process::GetLanguageRuntime(lldb::LanguageType language, bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001684{
1685 LanguageRuntimeCollection::iterator pos;
1686 pos = m_language_runtimes.find (language);
Jim Inghamab175242012-03-10 00:22:19 +00001687 if (pos == m_language_runtimes.end() || (retry_if_null && !(*pos).second))
Jim Ingham22777012010-09-23 02:01:19 +00001688 {
Jim Inghamab175242012-03-10 00:22:19 +00001689 lldb::LanguageRuntimeSP runtime_sp(LanguageRuntime::FindPlugin(this, language));
Jim Ingham22777012010-09-23 02:01:19 +00001690
Jim Inghamab175242012-03-10 00:22:19 +00001691 m_language_runtimes[language] = runtime_sp;
1692 return runtime_sp.get();
Jim Ingham22777012010-09-23 02:01:19 +00001693 }
1694 else
1695 return (*pos).second.get();
1696}
1697
1698CPPLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001699Process::GetCPPLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001700{
Jim Inghamab175242012-03-10 00:22:19 +00001701 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus, retry_if_null);
Jim Ingham22777012010-09-23 02:01:19 +00001702 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
1703 return static_cast<CPPLanguageRuntime *> (runtime);
1704 return NULL;
1705}
1706
1707ObjCLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001708Process::GetObjCLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001709{
Jim Inghamab175242012-03-10 00:22:19 +00001710 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC, retry_if_null);
Jim Ingham22777012010-09-23 02:01:19 +00001711 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC)
1712 return static_cast<ObjCLanguageRuntime *> (runtime);
1713 return NULL;
1714}
1715
Enrico Granatafd4c84e2012-05-21 16:51:35 +00001716bool
1717Process::IsPossibleDynamicValue (ValueObject& in_value)
1718{
1719 if (in_value.IsDynamic())
1720 return false;
1721 LanguageType known_type = in_value.GetObjectRuntimeLanguage();
1722
1723 if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC)
1724 {
1725 LanguageRuntime *runtime = GetLanguageRuntime (known_type);
1726 return runtime ? runtime->CouldHaveDynamicValue(in_value) : false;
1727 }
1728
1729 LanguageRuntime *cpp_runtime = GetLanguageRuntime (eLanguageTypeC_plus_plus);
1730 if (cpp_runtime && cpp_runtime->CouldHaveDynamicValue(in_value))
1731 return true;
1732
1733 LanguageRuntime *objc_runtime = GetLanguageRuntime (eLanguageTypeObjC);
1734 return objc_runtime ? objc_runtime->CouldHaveDynamicValue(in_value) : false;
1735}
1736
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001737BreakpointSiteList &
1738Process::GetBreakpointSiteList()
1739{
1740 return m_breakpoint_site_list;
1741}
1742
1743const BreakpointSiteList &
1744Process::GetBreakpointSiteList() const
1745{
1746 return m_breakpoint_site_list;
1747}
1748
1749
1750void
1751Process::DisableAllBreakpointSites ()
1752{
Greg Claytond8cf1a12013-06-12 00:46:38 +00001753 m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void {
1754// bp_site->SetEnabled(true);
1755 DisableBreakpointSite(bp_site);
1756 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001757}
1758
1759Error
1760Process::ClearBreakpointSiteByID (lldb::user_id_t break_id)
1761{
1762 Error error (DisableBreakpointSiteByID (break_id));
1763
1764 if (error.Success())
1765 m_breakpoint_site_list.Remove(break_id);
1766
1767 return error;
1768}
1769
1770Error
1771Process::DisableBreakpointSiteByID (lldb::user_id_t break_id)
1772{
1773 Error error;
1774 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1775 if (bp_site_sp)
1776 {
1777 if (bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00001778 error = DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001779 }
1780 else
1781 {
Daniel Malead01b2952012-11-29 21:49:15 +00001782 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001783 }
1784
1785 return error;
1786}
1787
1788Error
1789Process::EnableBreakpointSiteByID (lldb::user_id_t break_id)
1790{
1791 Error error;
1792 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1793 if (bp_site_sp)
1794 {
1795 if (!bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00001796 error = EnableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001797 }
1798 else
1799 {
Daniel Malead01b2952012-11-29 21:49:15 +00001800 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001801 }
1802 return error;
1803}
1804
Stephen Wilson50bd94f2010-07-17 00:56:13 +00001805lldb::break_id_t
Greg Claytone1cd1be2012-01-29 20:56:30 +00001806Process::CreateBreakpointSite (const BreakpointLocationSP &owner, bool use_hardware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001807{
Jim Ingham1460e4b2014-01-10 23:46:59 +00001808 addr_t load_addr = LLDB_INVALID_ADDRESS;
1809
1810 bool show_error = true;
1811 switch (GetState())
1812 {
1813 case eStateInvalid:
1814 case eStateUnloaded:
1815 case eStateConnected:
1816 case eStateAttaching:
1817 case eStateLaunching:
1818 case eStateDetached:
1819 case eStateExited:
1820 show_error = false;
1821 break;
1822
1823 case eStateStopped:
1824 case eStateRunning:
1825 case eStateStepping:
1826 case eStateCrashed:
1827 case eStateSuspended:
1828 show_error = IsAlive();
1829 break;
1830 }
1831
1832 // Reset the IsIndirect flag here, in case the location changes from
1833 // pointing to a indirect symbol to a regular symbol.
1834 owner->SetIsIndirect (false);
1835
1836 if (owner->ShouldResolveIndirectFunctions())
1837 {
1838 Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
1839 if (symbol && symbol->IsIndirect())
1840 {
1841 Error error;
1842 load_addr = ResolveIndirectFunction (&symbol->GetAddress(), error);
1843 if (!error.Success() && show_error)
1844 {
Greg Clayton44d93782014-01-27 23:43:24 +00001845 m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to resolve indirect function at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
1846 symbol->GetAddress().GetLoadAddress(&m_target),
1847 owner->GetBreakpoint().GetID(),
1848 owner->GetID(),
1849 error.AsCString() ? error.AsCString() : "unkown error");
Jim Ingham1460e4b2014-01-10 23:46:59 +00001850 return LLDB_INVALID_BREAK_ID;
1851 }
1852 Address resolved_address(load_addr);
1853 load_addr = resolved_address.GetOpcodeLoadAddress (&m_target);
1854 owner->SetIsIndirect(true);
1855 }
1856 else
1857 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
1858 }
1859 else
1860 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
1861
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001862 if (load_addr != LLDB_INVALID_ADDRESS)
1863 {
1864 BreakpointSiteSP bp_site_sp;
1865
1866 // Look up this breakpoint site. If it exists, then add this new owner, otherwise
1867 // create a new breakpoint site and add it.
1868
1869 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr);
1870
1871 if (bp_site_sp)
1872 {
1873 bp_site_sp->AddOwner (owner);
1874 owner->SetBreakpointSite (bp_site_sp);
1875 return bp_site_sp->GetID();
1876 }
1877 else
1878 {
Greg Claytonc7bece562013-01-25 18:06:21 +00001879 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, use_hardware));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001880 if (bp_site_sp)
1881 {
Greg Claytoneb023e72013-10-11 19:48:25 +00001882 Error error = EnableBreakpointSite (bp_site_sp.get());
1883 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001884 {
1885 owner->SetBreakpointSite (bp_site_sp);
1886 return m_breakpoint_site_list.Add (bp_site_sp);
1887 }
Greg Claytoneb023e72013-10-11 19:48:25 +00001888 else
1889 {
Greg Claytonfbb76342013-11-20 21:07:01 +00001890 if (show_error)
1891 {
1892 // Report error for setting breakpoint...
Greg Clayton44d93782014-01-27 23:43:24 +00001893 m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to set breakpoint site at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
1894 load_addr,
1895 owner->GetBreakpoint().GetID(),
1896 owner->GetID(),
1897 error.AsCString() ? error.AsCString() : "unkown error");
Greg Claytonfbb76342013-11-20 21:07:01 +00001898 }
Greg Claytoneb023e72013-10-11 19:48:25 +00001899 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001900 }
1901 }
1902 }
1903 // We failed to enable the breakpoint
1904 return LLDB_INVALID_BREAK_ID;
1905
1906}
1907
1908void
1909Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp)
1910{
1911 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id);
1912 if (num_owners == 0)
1913 {
Jim Inghamf1ff3bb2013-04-06 00:16:39 +00001914 // Don't try to disable the site if we don't have a live process anymore.
1915 if (IsAlive())
1916 DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001917 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
1918 }
1919}
1920
1921
1922size_t
1923Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
1924{
1925 size_t bytes_removed = 0;
Jim Ingham20c77192011-06-29 19:42:28 +00001926 BreakpointSiteList bp_sites_in_range;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001927
Jim Ingham20c77192011-06-29 19:42:28 +00001928 if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001929 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00001930 bp_sites_in_range.ForEach([bp_addr, size, buf, &bytes_removed](BreakpointSite *bp_site) -> void {
1931 if (bp_site->GetType() == BreakpointSite::eSoftware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001932 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00001933 addr_t intersect_addr;
1934 size_t intersect_size;
1935 size_t opcode_offset;
1936 if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset))
Jim Ingham20c77192011-06-29 19:42:28 +00001937 {
1938 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
1939 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size);
Greg Claytond8cf1a12013-06-12 00:46:38 +00001940 assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
Jim Ingham20c77192011-06-29 19:42:28 +00001941 size_t buf_offset = intersect_addr - bp_addr;
Greg Claytond8cf1a12013-06-12 00:46:38 +00001942 ::memcpy(buf + buf_offset, bp_site->GetSavedOpcodeBytes() + opcode_offset, intersect_size);
Jim Ingham20c77192011-06-29 19:42:28 +00001943 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001944 }
Greg Claytond8cf1a12013-06-12 00:46:38 +00001945 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001946 }
1947 return bytes_removed;
1948}
1949
1950
Greg Claytonded470d2011-03-19 01:12:21 +00001951
1952size_t
1953Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
1954{
1955 PlatformSP platform_sp (m_target.GetPlatform());
1956 if (platform_sp)
1957 return platform_sp->GetSoftwareBreakpointTrapOpcode (m_target, bp_site);
1958 return 0;
1959}
1960
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001961Error
1962Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site)
1963{
1964 Error error;
1965 assert (bp_site != NULL);
Greg Clayton5160ce52013-03-27 23:08:40 +00001966 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001967 const addr_t bp_addr = bp_site->GetLoadAddress();
1968 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001969 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64, bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001970 if (bp_site->IsEnabled())
1971 {
1972 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001973 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- already enabled", bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001974 return error;
1975 }
1976
1977 if (bp_addr == LLDB_INVALID_ADDRESS)
1978 {
1979 error.SetErrorString("BreakpointSite contains an invalid load address.");
1980 return error;
1981 }
1982 // Ask the lldb::Process subclass to fill in the correct software breakpoint
1983 // trap for the breakpoint site
1984 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
1985
1986 if (bp_opcode_size == 0)
1987 {
Daniel Malead01b2952012-11-29 21:49:15 +00001988 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%" PRIx64, bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001989 }
1990 else
1991 {
1992 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
1993
1994 if (bp_opcode_bytes == NULL)
1995 {
1996 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode.");
1997 return error;
1998 }
1999
2000 // Save the original opcode by reading it
2001 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size)
2002 {
2003 // Write a software breakpoint in place of the original opcode
2004 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2005 {
2006 uint8_t verify_bp_opcode_bytes[64];
2007 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2008 {
2009 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0)
2010 {
2011 bp_site->SetEnabled(true);
2012 bp_site->SetType (BreakpointSite::eSoftware);
2013 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002014 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002015 bp_site->GetID(),
2016 (uint64_t)bp_addr);
2017 }
2018 else
Greg Clayton86edbf42011-10-26 00:56:27 +00002019 error.SetErrorString("failed to verify the breakpoint trap in memory.");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002020 }
2021 else
2022 error.SetErrorString("Unable to read memory to verify breakpoint trap.");
2023 }
2024 else
2025 error.SetErrorString("Unable to write breakpoint trap to memory.");
2026 }
2027 else
2028 error.SetErrorString("Unable to read memory at breakpoint address.");
2029 }
Stephen Wilson78a4feb2011-01-12 04:20:03 +00002030 if (log && error.Fail())
Daniel Malead01b2952012-11-29 21:49:15 +00002031 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002032 bp_site->GetID(),
2033 (uint64_t)bp_addr,
2034 error.AsCString());
2035 return error;
2036}
2037
2038Error
2039Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
2040{
2041 Error error;
2042 assert (bp_site != NULL);
Greg Clayton5160ce52013-03-27 23:08:40 +00002043 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002044 addr_t bp_addr = bp_site->GetLoadAddress();
2045 lldb::user_id_t breakID = bp_site->GetID();
2046 if (log)
Jim Ingham299c0c12013-02-15 02:06:30 +00002047 log->Printf ("Process::DisableSoftwareBreakpoint (breakID = %" PRIu64 ") addr = 0x%" PRIx64, breakID, (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002048
2049 if (bp_site->IsHardware())
2050 {
2051 error.SetErrorString("Breakpoint site is a hardware breakpoint.");
2052 }
2053 else if (bp_site->IsEnabled())
2054 {
2055 const size_t break_op_size = bp_site->GetByteSize();
2056 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
2057 if (break_op_size > 0)
2058 {
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00002059 // Clear a software breakpoint instruction
Greg Claytonc982c762010-07-09 20:39:50 +00002060 uint8_t curr_break_op[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002061 assert (break_op_size <= sizeof(curr_break_op));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002062 bool break_op_found = false;
2063
2064 // Read the breakpoint opcode
2065 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
2066 {
2067 bool verify = false;
2068 // Make sure we have the a breakpoint opcode exists at this address
2069 if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
2070 {
2071 break_op_found = true;
2072 // We found a valid breakpoint opcode at this address, now restore
2073 // the saved opcode.
2074 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size)
2075 {
2076 verify = true;
2077 }
2078 else
2079 error.SetErrorString("Memory write failed when restoring original opcode.");
2080 }
2081 else
2082 {
2083 error.SetErrorString("Original breakpoint trap is no longer in memory.");
2084 // Set verify to true and so we can check if the original opcode has already been restored
2085 verify = true;
2086 }
2087
2088 if (verify)
2089 {
Greg Claytonc982c762010-07-09 20:39:50 +00002090 uint8_t verify_opcode[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002091 assert (break_op_size < sizeof(verify_opcode));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002092 // Verify that our original opcode made it back to the inferior
2093 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size)
2094 {
2095 // compare the memory we just read with the original opcode
2096 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
2097 {
2098 // SUCCESS
2099 bp_site->SetEnabled(false);
2100 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002101 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS", bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002102 return error;
2103 }
2104 else
2105 {
2106 if (break_op_found)
2107 error.SetErrorString("Failed to restore original opcode.");
2108 }
2109 }
2110 else
2111 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored.");
2112 }
2113 }
2114 else
2115 error.SetErrorString("Unable to read memory that should contain the breakpoint trap.");
2116 }
2117 }
2118 else
2119 {
2120 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002121 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- already disabled", bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002122 return error;
2123 }
2124
2125 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002126 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002127 bp_site->GetID(),
2128 (uint64_t)bp_addr,
2129 error.AsCString());
2130 return error;
2131
2132}
2133
Greg Clayton58be07b2011-01-07 06:08:19 +00002134// Uncomment to verify memory caching works after making changes to caching code
2135//#define VERIFY_MEMORY_READS
2136
Sean Callanan64c0cf22012-06-07 22:26:42 +00002137size_t
2138Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
2139{
Jason Molendaa7b5afa2013-11-15 00:17:32 +00002140 error.Clear();
Sean Callanan64c0cf22012-06-07 22:26:42 +00002141 if (!GetDisableMemoryCache())
2142 {
Greg Clayton58be07b2011-01-07 06:08:19 +00002143#if defined (VERIFY_MEMORY_READS)
Sean Callanan64c0cf22012-06-07 22:26:42 +00002144 // Memory caching is enabled, with debug verification
2145
2146 if (buf && size)
2147 {
2148 // Uncomment the line below to make sure memory caching is working.
2149 // I ran this through the test suite and got no assertions, so I am
2150 // pretty confident this is working well. If any changes are made to
2151 // memory caching, uncomment the line below and test your changes!
2152
2153 // Verify all memory reads by using the cache first, then redundantly
2154 // reading the same memory from the inferior and comparing to make sure
2155 // everything is exactly the same.
2156 std::string verify_buf (size, '\0');
2157 assert (verify_buf.size() == size);
2158 const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error);
2159 Error verify_error;
2160 const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error);
2161 assert (cache_bytes_read == verify_bytes_read);
2162 assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
2163 assert (verify_error.Success() == error.Success());
2164 return cache_bytes_read;
2165 }
2166 return 0;
2167#else // !defined(VERIFY_MEMORY_READS)
2168 // Memory caching is enabled, without debug verification
2169
2170 return m_memory_cache.Read (addr, buf, size, error);
2171#endif // defined (VERIFY_MEMORY_READS)
Greg Clayton58be07b2011-01-07 06:08:19 +00002172 }
Sean Callanan64c0cf22012-06-07 22:26:42 +00002173 else
2174 {
2175 // Memory caching is disabled
2176
2177 return ReadMemoryFromInferior (addr, buf, size, error);
2178 }
Greg Clayton58be07b2011-01-07 06:08:19 +00002179}
Greg Clayton58be07b2011-01-07 06:08:19 +00002180
Greg Clayton4c82d422012-05-18 23:20:01 +00002181size_t
2182Process::ReadCStringFromMemory (addr_t addr, std::string &out_str, Error &error)
2183{
Greg Claytonde87c0f2012-05-19 00:18:00 +00002184 char buf[256];
Greg Clayton4c82d422012-05-18 23:20:01 +00002185 out_str.clear();
2186 addr_t curr_addr = addr;
2187 while (1)
2188 {
2189 size_t length = ReadCStringFromMemory (curr_addr, buf, sizeof(buf), error);
2190 if (length == 0)
2191 break;
2192 out_str.append(buf, length);
2193 // If we got "length - 1" bytes, we didn't get the whole C string, we
2194 // need to read some more characters
2195 if (length == sizeof(buf) - 1)
2196 curr_addr += length;
2197 else
2198 break;
2199 }
2200 return out_str.size();
2201}
2202
Greg Clayton58be07b2011-01-07 06:08:19 +00002203
2204size_t
Ashok Thirumurthi6ac9d132013-04-19 15:58:38 +00002205Process::ReadStringFromMemory (addr_t addr, char *dst, size_t max_bytes, Error &error,
2206 size_t type_width)
2207{
2208 size_t total_bytes_read = 0;
2209 if (dst && max_bytes && type_width && max_bytes >= type_width)
2210 {
2211 // Ensure a null terminator independent of the number of bytes that is read.
2212 memset (dst, 0, max_bytes);
2213 size_t bytes_left = max_bytes - type_width;
2214
2215 const char terminator[4] = {'\0', '\0', '\0', '\0'};
2216 assert(sizeof(terminator) >= type_width &&
2217 "Attempting to validate a string with more than 4 bytes per character!");
2218
2219 addr_t curr_addr = addr;
2220 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2221 char *curr_dst = dst;
2222
2223 error.Clear();
2224 while (bytes_left > 0 && error.Success())
2225 {
2226 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2227 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2228 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2229
2230 if (bytes_read == 0)
2231 break;
2232
2233 // Search for a null terminator of correct size and alignment in bytes_read
2234 size_t aligned_start = total_bytes_read - total_bytes_read % type_width;
2235 for (size_t i = aligned_start; i + type_width <= total_bytes_read + bytes_read; i += type_width)
2236 if (::strncmp(&dst[i], terminator, type_width) == 0)
2237 {
2238 error.Clear();
2239 return i;
2240 }
2241
2242 total_bytes_read += bytes_read;
2243 curr_dst += bytes_read;
2244 curr_addr += bytes_read;
2245 bytes_left -= bytes_read;
2246 }
2247 }
2248 else
2249 {
2250 if (max_bytes)
2251 error.SetErrorString("invalid arguments");
2252 }
2253 return total_bytes_read;
2254}
2255
2256// Deprecated in favor of ReadStringFromMemory which has wchar support and correct code to find
2257// null terminators.
2258size_t
Greg Claytone91b7952011-12-15 03:14:23 +00002259Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len, Error &result_error)
Greg Clayton8b82f082011-04-12 05:54:46 +00002260{
2261 size_t total_cstr_len = 0;
2262 if (dst && dst_max_len)
2263 {
Greg Claytone91b7952011-12-15 03:14:23 +00002264 result_error.Clear();
Greg Clayton8b82f082011-04-12 05:54:46 +00002265 // NULL out everything just to be safe
2266 memset (dst, 0, dst_max_len);
2267 Error error;
2268 addr_t curr_addr = addr;
2269 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2270 size_t bytes_left = dst_max_len - 1;
2271 char *curr_dst = dst;
2272
2273 while (bytes_left > 0)
2274 {
2275 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2276 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2277 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2278
2279 if (bytes_read == 0)
2280 {
Greg Claytone91b7952011-12-15 03:14:23 +00002281 result_error = error;
Greg Clayton8b82f082011-04-12 05:54:46 +00002282 dst[total_cstr_len] = '\0';
2283 break;
2284 }
2285 const size_t len = strlen(curr_dst);
2286
2287 total_cstr_len += len;
2288
2289 if (len < bytes_to_read)
2290 break;
2291
2292 curr_dst += bytes_read;
2293 curr_addr += bytes_read;
2294 bytes_left -= bytes_read;
2295 }
2296 }
Greg Claytone91b7952011-12-15 03:14:23 +00002297 else
2298 {
2299 if (dst == NULL)
2300 result_error.SetErrorString("invalid arguments");
2301 else
2302 result_error.Clear();
2303 }
Greg Clayton8b82f082011-04-12 05:54:46 +00002304 return total_cstr_len;
2305}
2306
2307size_t
Greg Clayton58be07b2011-01-07 06:08:19 +00002308Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error)
2309{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002310 if (buf == NULL || size == 0)
2311 return 0;
2312
2313 size_t bytes_read = 0;
2314 uint8_t *bytes = (uint8_t *)buf;
2315
2316 while (bytes_read < size)
2317 {
2318 const size_t curr_size = size - bytes_read;
2319 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read,
2320 bytes + bytes_read,
2321 curr_size,
2322 error);
2323 bytes_read += curr_bytes_read;
2324 if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2325 break;
2326 }
2327
2328 // Replace any software breakpoint opcodes that fall into this range back
2329 // into "buf" before we return
2330 if (bytes_read > 0)
2331 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf);
2332 return bytes_read;
2333}
2334
Greg Clayton58a4c462010-12-16 20:01:20 +00002335uint64_t
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002336Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error)
Greg Clayton58a4c462010-12-16 20:01:20 +00002337{
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002338 Scalar scalar;
2339 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error))
2340 return scalar.ULongLong(fail_value);
2341 return fail_value;
2342}
2343
2344addr_t
2345Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
2346{
2347 Scalar scalar;
2348 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error))
2349 return scalar.ULongLong(LLDB_INVALID_ADDRESS);
2350 return LLDB_INVALID_ADDRESS;
2351}
2352
2353
2354bool
2355Process::WritePointerToMemory (lldb::addr_t vm_addr,
2356 lldb::addr_t ptr_value,
2357 Error &error)
2358{
2359 Scalar scalar;
2360 const uint32_t addr_byte_size = GetAddressByteSize();
2361 if (addr_byte_size <= 4)
2362 scalar = (uint32_t)ptr_value;
Greg Clayton58a4c462010-12-16 20:01:20 +00002363 else
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002364 scalar = ptr_value;
2365 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size;
Greg Clayton58a4c462010-12-16 20:01:20 +00002366}
2367
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002368size_t
2369Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error)
2370{
2371 size_t bytes_written = 0;
2372 const uint8_t *bytes = (const uint8_t *)buf;
2373
2374 while (bytes_written < size)
2375 {
2376 const size_t curr_size = size - bytes_written;
2377 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written,
2378 bytes + bytes_written,
2379 curr_size,
2380 error);
2381 bytes_written += curr_bytes_written;
2382 if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2383 break;
2384 }
2385 return bytes_written;
2386}
2387
2388size_t
2389Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
2390{
Greg Clayton58be07b2011-01-07 06:08:19 +00002391#if defined (ENABLE_MEMORY_CACHING)
2392 m_memory_cache.Flush (addr, size);
2393#endif
2394
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002395 if (buf == NULL || size == 0)
2396 return 0;
Jim Ingham78a685a2011-04-16 00:01:13 +00002397
Jim Ingham4b536182011-08-09 02:12:22 +00002398 m_mod_id.BumpMemoryID();
Jim Ingham78a685a2011-04-16 00:01:13 +00002399
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002400 // We need to write any data that would go where any current software traps
2401 // (enabled software breakpoints) any software traps (breakpoints) that we
2402 // may have placed in our tasks memory.
2403
Greg Claytond8cf1a12013-06-12 00:46:38 +00002404 BreakpointSiteList bp_sites_in_range;
2405
2406 if (m_breakpoint_site_list.FindInRange (addr, addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002407 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002408 // No breakpoint sites overlap
2409 if (bp_sites_in_range.IsEmpty())
2410 return WriteMemoryPrivate (addr, buf, size, error);
2411 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002412 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002413 const uint8_t *ubuf = (const uint8_t *)buf;
2414 uint64_t bytes_written = 0;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002415
Greg Claytond8cf1a12013-06-12 00:46:38 +00002416 bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, &error](BreakpointSite *bp) -> void {
2417
2418 if (error.Success())
2419 {
2420 addr_t intersect_addr;
2421 size_t intersect_size;
2422 size_t opcode_offset;
2423 const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
2424 assert(intersects);
2425 assert(addr <= intersect_addr && intersect_addr < addr + size);
2426 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
2427 assert(opcode_offset + intersect_size <= bp->GetByteSize());
2428
2429 // Check for bytes before this breakpoint
2430 const addr_t curr_addr = addr + bytes_written;
2431 if (intersect_addr > curr_addr)
2432 {
2433 // There are some bytes before this breakpoint that we need to
2434 // just write to memory
2435 size_t curr_size = intersect_addr - curr_addr;
2436 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr,
2437 ubuf + bytes_written,
2438 curr_size,
2439 error);
2440 bytes_written += curr_bytes_written;
2441 if (curr_bytes_written != curr_size)
2442 {
2443 // We weren't able to write all of the requested bytes, we
2444 // are done looping and will return the number of bytes that
2445 // we have written so far.
2446 if (error.Success())
2447 error.SetErrorToGenericError();
2448 }
2449 }
2450 // Now write any bytes that would cover up any software breakpoints
2451 // directly into the breakpoint opcode buffer
2452 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
2453 bytes_written += intersect_size;
2454 }
2455 });
2456
2457 if (bytes_written < size)
2458 bytes_written += WriteMemoryPrivate (addr + bytes_written,
2459 ubuf + bytes_written,
2460 size - bytes_written,
2461 error);
2462 }
2463 }
2464 else
2465 {
2466 return WriteMemoryPrivate (addr, buf, size, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002467 }
2468
2469 // Write any remaining bytes after the last breakpoint if we have any left
Greg Claytond8cf1a12013-06-12 00:46:38 +00002470 return 0; //bytes_written;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002471}
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002472
2473size_t
Greg Claytonc7bece562013-01-25 18:06:21 +00002474Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, size_t byte_size, Error &error)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002475{
2476 if (byte_size == UINT32_MAX)
2477 byte_size = scalar.GetByteSize();
2478 if (byte_size > 0)
2479 {
2480 uint8_t buf[32];
2481 const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error);
2482 if (mem_size > 0)
2483 return WriteMemory(addr, buf, mem_size, error);
2484 else
2485 error.SetErrorString ("failed to get scalar as memory data");
2486 }
2487 else
2488 {
2489 error.SetErrorString ("invalid scalar value");
2490 }
2491 return 0;
2492}
2493
2494size_t
2495Process::ReadScalarIntegerFromMemory (addr_t addr,
2496 uint32_t byte_size,
2497 bool is_signed,
2498 Scalar &scalar,
2499 Error &error)
2500{
Greg Clayton7060f892013-05-01 23:41:30 +00002501 uint64_t uval = 0;
2502 if (byte_size == 0)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002503 {
Greg Clayton7060f892013-05-01 23:41:30 +00002504 error.SetErrorString ("byte size is zero");
2505 }
2506 else if (byte_size & (byte_size - 1))
2507 {
2508 error.SetErrorStringWithFormat ("byte size %u is not a power of 2", byte_size);
2509 }
2510 else if (byte_size <= sizeof(uval))
2511 {
2512 const size_t bytes_read = ReadMemory (addr, &uval, byte_size, error);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002513 if (bytes_read == byte_size)
2514 {
2515 DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize());
Greg Claytonc7bece562013-01-25 18:06:21 +00002516 lldb::offset_t offset = 0;
Greg Clayton7060f892013-05-01 23:41:30 +00002517 if (byte_size <= 4)
2518 scalar = data.GetMaxU32 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002519 else
Greg Clayton7060f892013-05-01 23:41:30 +00002520 scalar = data.GetMaxU64 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002521 if (is_signed)
2522 scalar.SignExtend(byte_size * 8);
2523 return bytes_read;
2524 }
2525 }
2526 else
2527 {
2528 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
2529 }
2530 return 0;
2531}
2532
Greg Claytond495c532011-05-17 03:37:42 +00002533#define USE_ALLOCATE_MEMORY_CACHE 1
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002534addr_t
2535Process::AllocateMemory(size_t size, uint32_t permissions, Error &error)
2536{
Jim Inghamf72ce3a2011-06-20 17:32:44 +00002537 if (GetPrivateState() != eStateStopped)
2538 return LLDB_INVALID_ADDRESS;
2539
Greg Claytond495c532011-05-17 03:37:42 +00002540#if defined (USE_ALLOCATE_MEMORY_CACHE)
2541 return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2542#else
Greg Claytonb2daec92011-01-23 19:58:49 +00002543 addr_t allocated_addr = DoAllocateMemory (size, permissions, error);
Greg Clayton5160ce52013-03-27 23:08:40 +00002544 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002545 if (log)
Greg Clayton45989072013-10-23 18:24:30 +00002546 log->Printf("Process::AllocateMemory(size=%" PRIu64 ", permissions=%s) => 0x%16.16" PRIx64 " (m_stop_id = %u m_memory_id = %u)",
Deepak Panickald66b50c2013-10-22 12:27:43 +00002547 (uint64_t)size,
Greg Claytond495c532011-05-17 03:37:42 +00002548 GetPermissionsAsCString (permissions),
Greg Claytonb2daec92011-01-23 19:58:49 +00002549 (uint64_t)allocated_addr,
Jim Ingham4b536182011-08-09 02:12:22 +00002550 m_mod_id.GetStopID(),
2551 m_mod_id.GetMemoryID());
Greg Claytonb2daec92011-01-23 19:58:49 +00002552 return allocated_addr;
Greg Claytond495c532011-05-17 03:37:42 +00002553#endif
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002554}
2555
Sean Callanan90539452011-09-20 23:01:51 +00002556bool
2557Process::CanJIT ()
2558{
Sean Callanana7b443a2012-02-14 22:50:38 +00002559 if (m_can_jit == eCanJITDontKnow)
2560 {
Todd Fialaaf245d12014-06-30 21:05:18 +00002561 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Sean Callanana7b443a2012-02-14 22:50:38 +00002562 Error err;
2563
2564 uint64_t allocated_memory = AllocateMemory(8,
2565 ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
2566 err);
2567
2568 if (err.Success())
Todd Fialaaf245d12014-06-30 21:05:18 +00002569 {
Sean Callanana7b443a2012-02-14 22:50:38 +00002570 m_can_jit = eCanJITYes;
Todd Fialaaf245d12014-06-30 21:05:18 +00002571 if (log)
2572 log->Printf ("Process::%s pid %" PRIu64 " allocation test passed, CanJIT () is true", __FUNCTION__, GetID ());
2573 }
Sean Callanana7b443a2012-02-14 22:50:38 +00002574 else
Todd Fialaaf245d12014-06-30 21:05:18 +00002575 {
Sean Callanana7b443a2012-02-14 22:50:38 +00002576 m_can_jit = eCanJITNo;
Todd Fialaaf245d12014-06-30 21:05:18 +00002577 if (log)
2578 log->Printf ("Process::%s pid %" PRIu64 " allocation test failed, CanJIT () is false: %s", __FUNCTION__, GetID (), err.AsCString ());
2579 }
Sean Callanana7b443a2012-02-14 22:50:38 +00002580
2581 DeallocateMemory (allocated_memory);
2582 }
2583
Sean Callanan90539452011-09-20 23:01:51 +00002584 return m_can_jit == eCanJITYes;
2585}
2586
2587void
2588Process::SetCanJIT (bool can_jit)
2589{
2590 m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
2591}
2592
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002593Error
2594Process::DeallocateMemory (addr_t ptr)
2595{
Greg Claytond495c532011-05-17 03:37:42 +00002596 Error error;
2597#if defined (USE_ALLOCATE_MEMORY_CACHE)
2598 if (!m_allocated_memory_cache.DeallocateMemory(ptr))
2599 {
Daniel Malead01b2952012-11-29 21:49:15 +00002600 error.SetErrorStringWithFormat ("deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);
Greg Claytond495c532011-05-17 03:37:42 +00002601 }
2602#else
2603 error = DoDeallocateMemory (ptr);
Greg Claytonb2daec92011-01-23 19:58:49 +00002604
Greg Clayton5160ce52013-03-27 23:08:40 +00002605 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002606 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002607 log->Printf("Process::DeallocateMemory(addr=0x%16.16" PRIx64 ") => err = %s (m_stop_id = %u, m_memory_id = %u)",
Greg Claytonb2daec92011-01-23 19:58:49 +00002608 ptr,
2609 error.AsCString("SUCCESS"),
Jim Ingham4b536182011-08-09 02:12:22 +00002610 m_mod_id.GetStopID(),
2611 m_mod_id.GetMemoryID());
Greg Claytond495c532011-05-17 03:37:42 +00002612#endif
Greg Claytonb2daec92011-01-23 19:58:49 +00002613 return error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002614}
2615
Han Ming Ongc811d382012-11-17 00:33:14 +00002616
Greg Claytonc9660542012-02-05 02:38:54 +00002617ModuleSP
Greg Claytonc859e2d2012-02-13 23:10:39 +00002618Process::ReadModuleFromMemory (const FileSpec& file_spec,
Andrew MacPherson17220c12014-03-05 10:12:43 +00002619 lldb::addr_t header_addr,
2620 size_t size_to_read)
Greg Claytonc9660542012-02-05 02:38:54 +00002621{
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002622 ModuleSP module_sp (new Module (file_spec, ArchSpec()));
Greg Claytonc9660542012-02-05 02:38:54 +00002623 if (module_sp)
2624 {
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002625 Error error;
Andrew MacPherson17220c12014-03-05 10:12:43 +00002626 ObjectFile *objfile = module_sp->GetMemoryObjectFile (shared_from_this(), header_addr, error, size_to_read);
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002627 if (objfile)
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002628 return module_sp;
Greg Claytonc9660542012-02-05 02:38:54 +00002629 }
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002630 return ModuleSP();
Greg Claytonc9660542012-02-05 02:38:54 +00002631}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002632
2633Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002634Process::EnableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002635{
2636 Error error;
2637 error.SetErrorString("watchpoints are not supported");
2638 return error;
2639}
2640
2641Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002642Process::DisableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002643{
2644 Error error;
2645 error.SetErrorString("watchpoints are not supported");
2646 return error;
2647}
2648
2649StateType
2650Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp)
2651{
2652 StateType state;
2653 // Now wait for the process to launch and return control to us, and then
2654 // call DidLaunch:
2655 while (1)
2656 {
Greg Clayton6779606a2011-01-22 23:43:18 +00002657 event_sp.reset();
2658 state = WaitForStateChangedEventsPrivate (timeout, event_sp);
2659
Greg Clayton2637f822011-11-17 01:23:07 +00002660 if (StateIsStoppedState(state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002661 break;
Greg Clayton6779606a2011-01-22 23:43:18 +00002662
2663 // If state is invalid, then we timed out
2664 if (state == eStateInvalid)
2665 break;
2666
2667 if (event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002668 HandlePrivateEvent (event_sp);
2669 }
2670 return state;
2671}
2672
2673Error
Greg Claytonfbb76342013-11-20 21:07:01 +00002674Process::Launch (ProcessLaunchInfo &launch_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002675{
2676 Error error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002677 m_abi_sp.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002678 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002679 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00002680 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002681 m_os_ap.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002682 m_process_input_reader.reset();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002683
Greg Claytonaa149cb2011-08-11 02:48:45 +00002684 Module *exe_module = m_target.GetExecutableModulePointer();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002685 if (exe_module)
2686 {
Greg Clayton2289fa42011-04-30 01:09:13 +00002687 char local_exec_file_path[PATH_MAX];
2688 char platform_exec_file_path[PATH_MAX];
2689 exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path));
2690 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002691 if (exe_module->GetFileSpec().Exists())
2692 {
Greg Claytonfbb76342013-11-20 21:07:01 +00002693 // Install anything that might need to be installed prior to launching.
2694 // For host systems, this will do nothing, but if we are connected to a
2695 // remote platform it will install any needed binaries
2696 error = GetTarget().Install(&launch_info);
2697 if (error.Fail())
2698 return error;
2699
Greg Clayton71337622011-02-24 22:24:29 +00002700 if (PrivateStateThreadIsValid ())
2701 PausePrivateStateThread ();
2702
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002703 error = WillLaunch (exe_module);
2704 if (error.Success())
2705 {
Jim Ingham221d51c2013-05-08 00:35:16 +00002706 const bool restarted = false;
2707 SetPublicState (eStateLaunching, restarted);
Greg Claytone24c4ac2011-11-17 04:46:02 +00002708 m_should_detach = false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002709
Ed Maste64fad602013-07-29 20:58:06 +00002710 if (m_public_run_lock.TrySetRunning())
Greg Clayton69fd4be2012-09-04 20:29:05 +00002711 {
2712 // Now launch using these arguments.
2713 error = DoLaunch (exe_module, launch_info);
2714 }
2715 else
2716 {
2717 // This shouldn't happen
2718 error.SetErrorString("failed to acquire process run lock");
2719 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002720
2721 if (error.Fail())
2722 {
2723 if (GetID() != LLDB_INVALID_PROCESS_ID)
2724 {
2725 SetID (LLDB_INVALID_PROCESS_ID);
2726 const char *error_string = error.AsCString();
2727 if (error_string == NULL)
2728 error_string = "launch failed";
2729 SetExitStatus (-1, error_string);
2730 }
2731 }
2732 else
2733 {
2734 EventSP event_sp;
Greg Clayton1a38ea72011-06-22 01:42:17 +00002735 TimeValue timeout_time;
2736 timeout_time = TimeValue::Now();
2737 timeout_time.OffsetWithSeconds(10);
2738 StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002739
Greg Clayton1a38ea72011-06-22 01:42:17 +00002740 if (state == eStateInvalid || event_sp.get() == NULL)
2741 {
2742 // We were able to launch the process, but we failed to
2743 // catch the initial stop.
2744 SetExitStatus (0, "failed to catch stop after launch");
2745 Destroy();
2746 }
2747 else if (state == eStateStopped || state == eStateCrashed)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002748 {
Greg Clayton93d3c8332011-02-16 04:46:07 +00002749
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002750 DidLaunch ();
2751
Greg Claytonc859e2d2012-02-13 23:10:39 +00002752 DynamicLoader *dyld = GetDynamicLoader ();
2753 if (dyld)
2754 dyld->DidLaunch();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002755
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00002756 GetJITLoaders().DidLaunch();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002757
Jason Molendaeef51062013-11-05 03:57:19 +00002758 SystemRuntime *system_runtime = GetSystemRuntime ();
2759 if (system_runtime)
2760 system_runtime->DidLaunch();
2761
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002762 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002763 // This delays passing the stopped event to listeners till DidLaunch gets
2764 // a chance to complete...
2765 HandlePrivateEvent (event_sp);
Greg Clayton71337622011-02-24 22:24:29 +00002766
2767 if (PrivateStateThreadIsValid ())
2768 ResumePrivateStateThread ();
2769 else
2770 StartPrivateStateThread ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002771 }
2772 else if (state == eStateExited)
2773 {
2774 // We exited while trying to launch somehow. Don't call DidLaunch as that's
2775 // not likely to work, and return an invalid pid.
2776 HandlePrivateEvent (event_sp);
2777 }
2778 }
2779 }
2780 }
2781 else
2782 {
Greg Clayton86edbf42011-10-26 00:56:27 +00002783 error.SetErrorStringWithFormat("file doesn't exist: '%s'", local_exec_file_path);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002784 }
2785 }
2786 return error;
2787}
2788
Greg Claytonc3776bf2012-02-09 06:16:32 +00002789
2790Error
2791Process::LoadCore ()
2792{
2793 Error error = DoLoadCore();
2794 if (error.Success())
2795 {
2796 if (PrivateStateThreadIsValid ())
2797 ResumePrivateStateThread ();
2798 else
2799 StartPrivateStateThread ();
2800
Greg Claytonc859e2d2012-02-13 23:10:39 +00002801 DynamicLoader *dyld = GetDynamicLoader ();
2802 if (dyld)
2803 dyld->DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002804
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00002805 GetJITLoaders().DidAttach();
Greg Claytonc859e2d2012-02-13 23:10:39 +00002806
Jason Molendaeef51062013-11-05 03:57:19 +00002807 SystemRuntime *system_runtime = GetSystemRuntime ();
2808 if (system_runtime)
2809 system_runtime->DidAttach();
2810
Greg Claytonc859e2d2012-02-13 23:10:39 +00002811 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Greg Claytonc3776bf2012-02-09 06:16:32 +00002812 // We successfully loaded a core file, now pretend we stopped so we can
2813 // show all of the threads in the core file and explore the crashed
2814 // state.
2815 SetPrivateState (eStateStopped);
2816
2817 }
2818 return error;
2819}
2820
Greg Claytonc859e2d2012-02-13 23:10:39 +00002821DynamicLoader *
2822Process::GetDynamicLoader ()
2823{
2824 if (m_dyld_ap.get() == NULL)
2825 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
2826 return m_dyld_ap.get();
2827}
Greg Claytonc3776bf2012-02-09 06:16:32 +00002828
Todd Fialaaf245d12014-06-30 21:05:18 +00002829const lldb::DataBufferSP
2830Process::GetAuxvData()
2831{
2832 return DataBufferSP ();
2833}
2834
Andrew MacPherson17220c12014-03-05 10:12:43 +00002835JITLoaderList &
2836Process::GetJITLoaders ()
2837{
2838 if (!m_jit_loaders_ap)
2839 {
2840 m_jit_loaders_ap.reset(new JITLoaderList());
2841 JITLoader::LoadPlugins(this, *m_jit_loaders_ap);
2842 }
2843 return *m_jit_loaders_ap;
2844}
2845
Jason Molendaeef51062013-11-05 03:57:19 +00002846SystemRuntime *
2847Process::GetSystemRuntime ()
2848{
2849 if (m_system_runtime_ap.get() == NULL)
2850 m_system_runtime_ap.reset (SystemRuntime::FindPlugin(this));
2851 return m_system_runtime_ap.get();
2852}
2853
Greg Claytonc3776bf2012-02-09 06:16:32 +00002854
Jim Inghambb3a2832011-01-29 01:49:25 +00002855Process::NextEventAction::EventActionResult
2856Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002857{
Jim Inghambb3a2832011-01-29 01:49:25 +00002858 StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
2859 switch (state)
Greg Clayton19388cf2010-10-18 01:45:30 +00002860 {
Greg Clayton513c26c2011-01-29 07:10:55 +00002861 case eStateRunning:
Greg Clayton71337622011-02-24 22:24:29 +00002862 case eStateConnected:
Greg Clayton513c26c2011-01-29 07:10:55 +00002863 return eEventActionRetry;
2864
2865 case eStateStopped:
2866 case eStateCrashed:
Greg Claytonc9ed4782011-11-12 02:10:56 +00002867 {
2868 // During attach, prior to sending the eStateStopped event,
Jim Inghamb1e2e842012-04-12 18:49:31 +00002869 // lldb_private::Process subclasses must set the new process ID.
Greg Claytonc9ed4782011-11-12 02:10:56 +00002870 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
Jim Ingham221d51c2013-05-08 00:35:16 +00002871 // We don't want these events to be reported, so go set the ShouldReportStop here:
2872 m_process->GetThreadList().SetShouldReportStop (eVoteNo);
2873
Greg Claytonc9ed4782011-11-12 02:10:56 +00002874 if (m_exec_count > 0)
2875 {
2876 --m_exec_count;
Jim Ingham221d51c2013-05-08 00:35:16 +00002877 RequestResume();
Greg Claytonc9ed4782011-11-12 02:10:56 +00002878 return eEventActionRetry;
2879 }
2880 else
2881 {
2882 m_process->CompleteAttach ();
2883 return eEventActionSuccess;
2884 }
2885 }
Greg Clayton513c26c2011-01-29 07:10:55 +00002886 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00002887
Greg Clayton513c26c2011-01-29 07:10:55 +00002888 default:
2889 case eStateExited:
2890 case eStateInvalid:
Greg Clayton513c26c2011-01-29 07:10:55 +00002891 break;
Jim Inghambb3a2832011-01-29 01:49:25 +00002892 }
Greg Claytonc9ed4782011-11-12 02:10:56 +00002893
2894 m_exit_string.assign ("No valid Process");
2895 return eEventActionExit;
Jim Inghambb3a2832011-01-29 01:49:25 +00002896}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002897
Jim Inghambb3a2832011-01-29 01:49:25 +00002898Process::NextEventAction::EventActionResult
2899Process::AttachCompletionHandler::HandleBeingInterrupted()
2900{
2901 return eEventActionSuccess;
2902}
2903
2904const char *
2905Process::AttachCompletionHandler::GetExitString ()
2906{
2907 return m_exit_string.c_str();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002908}
2909
2910Error
Greg Clayton144f3a92011-11-15 03:53:30 +00002911Process::Attach (ProcessAttachInfo &attach_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002912{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002913 m_abi_sp.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002914 m_process_input_reader.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002915 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002916 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00002917 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002918 m_os_ap.reset();
Jim Ingham5aee1622010-08-09 23:31:02 +00002919
Greg Clayton144f3a92011-11-15 03:53:30 +00002920 lldb::pid_t attach_pid = attach_info.GetProcessID();
Greg Claytone996fd32011-03-08 22:40:15 +00002921 Error error;
Greg Clayton144f3a92011-11-15 03:53:30 +00002922 if (attach_pid == LLDB_INVALID_PROCESS_ID)
Jim Ingham5aee1622010-08-09 23:31:02 +00002923 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002924 char process_name[PATH_MAX];
Jim Ingham4299fdb2011-09-15 01:10:17 +00002925
Greg Clayton144f3a92011-11-15 03:53:30 +00002926 if (attach_info.GetExecutableFile().GetPath (process_name, sizeof(process_name)))
Jim Ingham2ecb7422010-08-17 21:54:19 +00002927 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002928 const bool wait_for_launch = attach_info.GetWaitForLaunch();
2929
2930 if (wait_for_launch)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002931 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002932 error = WillAttachToProcessWithName(process_name, wait_for_launch);
2933 if (error.Success())
2934 {
Ed Maste64fad602013-07-29 20:58:06 +00002935 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00002936 {
2937 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00002938 const bool restarted = false;
2939 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00002940 // Now attach using these arguments.
Jean-Daniel Dupas9c517c02013-12-23 22:32:54 +00002941 error = DoAttachToProcessWithName (process_name, attach_info);
Greg Clayton926cce72012-10-12 16:10:12 +00002942 }
2943 else
2944 {
2945 // This shouldn't happen
2946 error.SetErrorString("failed to acquire process run lock");
2947 }
Greg Claytone24c4ac2011-11-17 04:46:02 +00002948
Greg Clayton144f3a92011-11-15 03:53:30 +00002949 if (error.Fail())
2950 {
2951 if (GetID() != LLDB_INVALID_PROCESS_ID)
2952 {
2953 SetID (LLDB_INVALID_PROCESS_ID);
2954 if (error.AsCString() == NULL)
2955 error.SetErrorString("attach failed");
2956
2957 SetExitStatus(-1, error.AsCString());
2958 }
2959 }
2960 else
2961 {
2962 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
2963 StartPrivateStateThread();
2964 }
2965 return error;
2966 }
Greg Claytone996fd32011-03-08 22:40:15 +00002967 }
Greg Clayton144f3a92011-11-15 03:53:30 +00002968 else
Greg Claytone996fd32011-03-08 22:40:15 +00002969 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002970 ProcessInstanceInfoList process_infos;
2971 PlatformSP platform_sp (m_target.GetPlatform ());
2972
2973 if (platform_sp)
2974 {
2975 ProcessInstanceInfoMatch match_info;
2976 match_info.GetProcessInfo() = attach_info;
2977 match_info.SetNameMatchType (eNameMatchEquals);
2978 platform_sp->FindProcesses (match_info, process_infos);
2979 const uint32_t num_matches = process_infos.GetSize();
2980 if (num_matches == 1)
2981 {
2982 attach_pid = process_infos.GetProcessIDAtIndex(0);
2983 // Fall through and attach using the above process ID
2984 }
2985 else
2986 {
2987 match_info.GetProcessInfo().GetExecutableFile().GetPath (process_name, sizeof(process_name));
2988 if (num_matches > 1)
2989 error.SetErrorStringWithFormat ("more than one process named %s", process_name);
2990 else
2991 error.SetErrorStringWithFormat ("could not find a process named %s", process_name);
2992 }
2993 }
2994 else
2995 {
2996 error.SetErrorString ("invalid platform, can't find processes by name");
2997 return error;
2998 }
Greg Claytone996fd32011-03-08 22:40:15 +00002999 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003000 }
3001 else
Greg Clayton144f3a92011-11-15 03:53:30 +00003002 {
3003 error.SetErrorString ("invalid process name");
Greg Claytone996fd32011-03-08 22:40:15 +00003004 }
3005 }
Greg Clayton144f3a92011-11-15 03:53:30 +00003006
3007 if (attach_pid != LLDB_INVALID_PROCESS_ID)
Greg Claytone996fd32011-03-08 22:40:15 +00003008 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003009 error = WillAttachToProcessWithID(attach_pid);
Greg Claytone996fd32011-03-08 22:40:15 +00003010 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003011 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003012
Ed Maste64fad602013-07-29 20:58:06 +00003013 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00003014 {
3015 // Now attach using these arguments.
3016 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00003017 const bool restarted = false;
3018 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00003019 error = DoAttachToProcessWithID (attach_pid, attach_info);
3020 }
3021 else
3022 {
3023 // This shouldn't happen
3024 error.SetErrorString("failed to acquire process run lock");
3025 }
3026
Greg Clayton144f3a92011-11-15 03:53:30 +00003027 if (error.Success())
3028 {
3029
3030 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3031 StartPrivateStateThread();
3032 }
3033 else
Greg Claytone996fd32011-03-08 22:40:15 +00003034 {
3035 if (GetID() != LLDB_INVALID_PROCESS_ID)
3036 {
3037 SetID (LLDB_INVALID_PROCESS_ID);
3038 const char *error_string = error.AsCString();
3039 if (error_string == NULL)
3040 error_string = "attach failed";
3041
3042 SetExitStatus(-1, error_string);
3043 }
3044 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003045 }
3046 }
3047 return error;
3048}
3049
Greg Clayton93d3c8332011-02-16 04:46:07 +00003050void
3051Process::CompleteAttach ()
3052{
3053 // Let the process subclass figure out at much as it can about the process
3054 // before we go looking for a dynamic loader plug-in.
3055 DidAttach();
3056
Jim Ingham4299fdb2011-09-15 01:10:17 +00003057 // We just attached. If we have a platform, ask it for the process architecture, and if it isn't
3058 // the same as the one we've already set, switch architectures.
3059 PlatformSP platform_sp (m_target.GetPlatform ());
3060 assert (platform_sp.get());
3061 if (platform_sp)
3062 {
Greg Clayton70512312012-05-08 01:45:38 +00003063 const ArchSpec &target_arch = m_target.GetArchitecture();
Greg Clayton1e0c8842013-01-11 20:49:54 +00003064 if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture (target_arch, false, NULL))
Greg Clayton70512312012-05-08 01:45:38 +00003065 {
3066 ArchSpec platform_arch;
3067 platform_sp = platform_sp->GetPlatformForArchitecture (target_arch, &platform_arch);
3068 if (platform_sp)
3069 {
3070 m_target.SetPlatform (platform_sp);
3071 m_target.SetArchitecture(platform_arch);
3072 }
3073 }
3074 else
3075 {
3076 ProcessInstanceInfo process_info;
3077 platform_sp->GetProcessInfo (GetID(), process_info);
3078 const ArchSpec &process_arch = process_info.GetArchitecture();
Sean Callananbf4b7be2012-12-13 22:07:14 +00003079 if (process_arch.IsValid() && !m_target.GetArchitecture().IsExactMatch(process_arch))
Greg Clayton70512312012-05-08 01:45:38 +00003080 m_target.SetArchitecture (process_arch);
3081 }
Jim Ingham4299fdb2011-09-15 01:10:17 +00003082 }
3083
3084 // We have completed the attach, now it is time to find the dynamic loader
Greg Clayton93d3c8332011-02-16 04:46:07 +00003085 // plug-in
Greg Claytonc859e2d2012-02-13 23:10:39 +00003086 DynamicLoader *dyld = GetDynamicLoader ();
3087 if (dyld)
3088 dyld->DidAttach();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003089
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003090 GetJITLoaders().DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003091
Jason Molendaeef51062013-11-05 03:57:19 +00003092 SystemRuntime *system_runtime = GetSystemRuntime ();
3093 if (system_runtime)
3094 system_runtime->DidAttach();
3095
Greg Clayton56d9a1b2011-08-22 02:49:39 +00003096 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Greg Clayton93d3c8332011-02-16 04:46:07 +00003097 // Figure out which one is the executable, and set that in our target:
Enrico Granata17598482012-11-08 02:22:02 +00003098 const ModuleList &target_modules = m_target.GetImages();
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003099 Mutex::Locker modules_locker(target_modules.GetMutex());
3100 size_t num_modules = target_modules.GetSize();
3101 ModuleSP new_executable_module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003102
Andy Gibbsa297a972013-06-19 19:04:53 +00003103 for (size_t i = 0; i < num_modules; i++)
Greg Clayton93d3c8332011-02-16 04:46:07 +00003104 {
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003105 ModuleSP module_sp (target_modules.GetModuleAtIndexUnlocked (i));
Greg Clayton8b82f082011-04-12 05:54:46 +00003106 if (module_sp && module_sp->IsExecutable())
Greg Clayton93d3c8332011-02-16 04:46:07 +00003107 {
Greg Claytonaa149cb2011-08-11 02:48:45 +00003108 if (m_target.GetExecutableModulePointer() != module_sp.get())
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003109 new_executable_module_sp = module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003110 break;
3111 }
3112 }
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003113 if (new_executable_module_sp)
3114 m_target.SetExecutableModule (new_executable_module_sp, false);
Greg Clayton93d3c8332011-02-16 04:46:07 +00003115}
3116
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003117Error
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003118Process::ConnectRemote (Stream *strm, const char *remote_url)
Greg Claytonb766a732011-02-04 01:58:07 +00003119{
Greg Claytonb766a732011-02-04 01:58:07 +00003120 m_abi_sp.reset();
3121 m_process_input_reader.reset();
3122
3123 // Find the process and its architecture. Make sure it matches the architecture
3124 // of the current Target, and if not adjust it.
3125
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003126 Error error (DoConnectRemote (strm, remote_url));
Greg Claytonb766a732011-02-04 01:58:07 +00003127 if (error.Success())
3128 {
Greg Clayton71337622011-02-24 22:24:29 +00003129 if (GetID() != LLDB_INVALID_PROCESS_ID)
3130 {
Greg Clayton32e0a752011-03-30 18:16:51 +00003131 EventSP event_sp;
3132 StateType state = WaitForProcessStopPrivate(NULL, event_sp);
3133
3134 if (state == eStateStopped || state == eStateCrashed)
3135 {
3136 // If we attached and actually have a process on the other end, then
3137 // this ended up being the equivalent of an attach.
3138 CompleteAttach ();
3139
3140 // This delays passing the stopped event to listeners till
3141 // CompleteAttach gets a chance to complete...
3142 HandlePrivateEvent (event_sp);
3143
3144 }
Greg Clayton71337622011-02-24 22:24:29 +00003145 }
Greg Clayton32e0a752011-03-30 18:16:51 +00003146
3147 if (PrivateStateThreadIsValid ())
3148 ResumePrivateStateThread ();
3149 else
3150 StartPrivateStateThread ();
Greg Claytonb766a732011-02-04 01:58:07 +00003151 }
3152 return error;
3153}
3154
3155
3156Error
Jim Ingham3b8285d2012-04-19 01:40:33 +00003157Process::PrivateResume ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003158{
Greg Clayton5160ce52013-03-27 23:08:40 +00003159 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_STEP));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003160 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003161 log->Printf("Process::PrivateResume() m_stop_id = %u, public state: %s private state: %s",
Jim Ingham4b536182011-08-09 02:12:22 +00003162 m_mod_id.GetStopID(),
Jim Ingham444586b2011-01-24 06:34:17 +00003163 StateAsCString(m_public_state.GetValue()),
3164 StateAsCString(m_private_state.GetValue()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003165
3166 Error error (WillResume());
3167 // Tell the process it is about to resume before the thread list
3168 if (error.Success())
3169 {
Johnny Chenc4221e42010-12-02 20:53:05 +00003170 // Now let the thread list know we are about to resume so it
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003171 // can let all of our threads know that they are about to be
3172 // resumed. Threads will each be called with
3173 // Thread::WillResume(StateType) where StateType contains the state
3174 // that they are supposed to have when the process is resumed
3175 // (suspended/running/stepping). Threads should also check
3176 // their resume signal in lldb::Thread::GetResumeSignal()
Jim Ingham221d51c2013-05-08 00:35:16 +00003177 // to see if they are supposed to start back up with a signal.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003178 if (m_thread_list.WillResume())
3179 {
Jim Ingham372787f2012-04-07 00:00:41 +00003180 // Last thing, do the PreResumeActions.
3181 if (!RunPreResumeActions())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003182 {
Jim Ingham0161b492013-02-09 01:29:05 +00003183 error.SetErrorStringWithFormat ("Process::PrivateResume PreResumeActions failed, not resuming.");
Jim Ingham372787f2012-04-07 00:00:41 +00003184 }
3185 else
3186 {
3187 m_mod_id.BumpResumeID();
3188 error = DoResume();
3189 if (error.Success())
3190 {
3191 DidResume();
3192 m_thread_list.DidResume();
3193 if (log)
3194 log->Printf ("Process thinks the process has resumed.");
3195 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003196 }
3197 }
3198 else
3199 {
Jim Ingham513c6bb2012-09-01 01:02:41 +00003200 // Somebody wanted to run without running. So generate a continue & a stopped event,
3201 // and let the world handle them.
3202 if (log)
3203 log->Printf ("Process::PrivateResume() asked to simulate a start & stop.");
3204
3205 SetPrivateState(eStateRunning);
3206 SetPrivateState(eStateStopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003207 }
3208 }
Jim Ingham444586b2011-01-24 06:34:17 +00003209 else if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003210 log->Printf ("Process::PrivateResume() got an error \"%s\".", error.AsCString("<unknown error>"));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003211 return error;
3212}
3213
3214Error
Greg Claytonf9b57b92013-05-10 23:48:10 +00003215Process::Halt (bool clear_thread_plans)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003216{
Greg Claytonf9b57b92013-05-10 23:48:10 +00003217 // Don't clear the m_clear_thread_plans_on_stop, only set it to true if
3218 // in case it was already set and some thread plan logic calls halt on its
3219 // own.
3220 m_clear_thread_plans_on_stop |= clear_thread_plans;
3221
Jim Inghamaacc3182012-06-06 00:29:30 +00003222 // First make sure we aren't in the middle of handling an event, or we might restart. This is pretty weak, since
3223 // we could just straightaway get another event. It just narrows the window...
3224 m_currently_handling_event.WaitForValueEqualTo(false);
3225
3226
Jim Inghambb3a2832011-01-29 01:49:25 +00003227 // Pause our private state thread so we can ensure no one else eats
3228 // the stop event out from under us.
Jim Ingham0f16e732011-02-08 05:20:59 +00003229 Listener halt_listener ("lldb.process.halt_listener");
3230 HijackPrivateProcessEvents(&halt_listener);
Greg Clayton3af9ea52010-11-18 05:57:03 +00003231
Jim Inghambb3a2832011-01-29 01:49:25 +00003232 EventSP event_sp;
Greg Clayton513c26c2011-01-29 07:10:55 +00003233 Error error (WillHalt());
Jim Inghambb3a2832011-01-29 01:49:25 +00003234
Greg Clayton513c26c2011-01-29 07:10:55 +00003235 if (error.Success())
Jim Inghambb3a2832011-01-29 01:49:25 +00003236 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003237
Greg Clayton513c26c2011-01-29 07:10:55 +00003238 bool caused_stop = false;
3239
3240 // Ask the process subclass to actually halt our process
3241 error = DoHalt(caused_stop);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003242 if (error.Success())
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003243 {
Greg Clayton513c26c2011-01-29 07:10:55 +00003244 if (m_public_state.GetValue() == eStateAttaching)
3245 {
3246 SetExitStatus(SIGKILL, "Cancelled async attach.");
3247 Destroy ();
3248 }
3249 else
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003250 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003251 // If "caused_stop" is true, then DoHalt stopped the process. If
3252 // "caused_stop" is false, the process was already stopped.
3253 // If the DoHalt caused the process to stop, then we want to catch
3254 // this event and set the interrupted bool to true before we pass
3255 // this along so clients know that the process was interrupted by
3256 // a halt command.
3257 if (caused_stop)
Greg Clayton3af9ea52010-11-18 05:57:03 +00003258 {
Jim Ingham0f16e732011-02-08 05:20:59 +00003259 // Wait for 1 second for the process to stop.
Jim Inghambb3a2832011-01-29 01:49:25 +00003260 TimeValue timeout_time;
3261 timeout_time = TimeValue::Now();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003262 timeout_time.OffsetWithSeconds(10);
Jim Ingham0f16e732011-02-08 05:20:59 +00003263 bool got_event = halt_listener.WaitForEvent (&timeout_time, event_sp);
3264 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00003265
Jim Ingham0f16e732011-02-08 05:20:59 +00003266 if (!got_event || state == eStateInvalid)
Greg Clayton3af9ea52010-11-18 05:57:03 +00003267 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003268 // We timeout out and didn't get a stop event...
Jim Ingham0f16e732011-02-08 05:20:59 +00003269 error.SetErrorStringWithFormat ("Halt timed out. State = %s", StateAsCString(GetState()));
Greg Clayton3af9ea52010-11-18 05:57:03 +00003270 }
3271 else
3272 {
Greg Clayton2637f822011-11-17 01:23:07 +00003273 if (StateIsStoppedState (state, false))
Jim Inghambb3a2832011-01-29 01:49:25 +00003274 {
3275 // We caused the process to interrupt itself, so mark this
3276 // as such in the stop event so clients can tell an interrupted
3277 // process from a natural stop
3278 ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);
3279 }
3280 else
3281 {
Greg Clayton5160ce52013-03-27 23:08:40 +00003282 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Inghambb3a2832011-01-29 01:49:25 +00003283 if (log)
3284 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
3285 error.SetErrorString ("Did not get stopped event after halt.");
3286 }
Greg Clayton3af9ea52010-11-18 05:57:03 +00003287 }
3288 }
Jim Inghambb3a2832011-01-29 01:49:25 +00003289 DidHalt();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003290 }
3291 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003292 }
Jim Inghambb3a2832011-01-29 01:49:25 +00003293 // Resume our private state thread before we post the event (if any)
Jim Ingham0f16e732011-02-08 05:20:59 +00003294 RestorePrivateProcessEvents();
Jim Inghambb3a2832011-01-29 01:49:25 +00003295
3296 // Post any event we might have consumed. If all goes well, we will have
3297 // stopped the process, intercepted the event and set the interrupted
3298 // bool in the event. Post it to the private event queue and that will end up
3299 // correctly setting the state.
3300 if (event_sp)
3301 m_private_state_broadcaster.BroadcastEvent(event_sp);
3302
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003303 return error;
3304}
3305
3306Error
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003307Process::HaltForDestroyOrDetach(lldb::EventSP &exit_event_sp)
3308{
3309 Error error;
3310 if (m_public_state.GetValue() == eStateRunning)
3311 {
3312 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3313 if (log)
3314 log->Printf("Process::Destroy() About to halt.");
3315 error = Halt();
3316 if (error.Success())
3317 {
3318 // Consume the halt event.
3319 TimeValue timeout (TimeValue::Now());
3320 timeout.OffsetWithSeconds(1);
3321 StateType state = WaitForProcessToStop (&timeout, &exit_event_sp);
3322
3323 // If the process exited while we were waiting for it to stop, put the exited event into
3324 // the shared pointer passed in and return. Our caller doesn't need to do anything else, since
3325 // they don't have a process anymore...
3326
3327 if (state == eStateExited || m_private_state.GetValue() == eStateExited)
3328 {
3329 if (log)
3330 log->Printf("Process::HaltForDestroyOrDetach() Process exited while waiting to Halt.");
3331 return error;
3332 }
3333 else
3334 exit_event_sp.reset(); // It is ok to consume any non-exit stop events
3335
3336 if (state != eStateStopped)
3337 {
3338 if (log)
3339 log->Printf("Process::HaltForDestroyOrDetach() Halt failed to stop, state is: %s", StateAsCString(state));
3340 // If we really couldn't stop the process then we should just error out here, but if the
3341 // lower levels just bobbled sending the event and we really are stopped, then continue on.
3342 StateType private_state = m_private_state.GetValue();
3343 if (private_state != eStateStopped)
3344 {
3345 return error;
3346 }
3347 }
3348 }
3349 else
3350 {
3351 if (log)
3352 log->Printf("Process::HaltForDestroyOrDetach() Halt got error: %s", error.AsCString());
3353 }
3354 }
3355 return error;
3356}
3357
3358Error
Jim Inghamacff8952013-05-02 00:27:30 +00003359Process::Detach (bool keep_stopped)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003360{
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003361 EventSP exit_event_sp;
3362 Error error;
3363 m_destroy_in_process = true;
3364
3365 error = WillDetach();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003366
3367 if (error.Success())
3368 {
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003369 if (DetachRequiresHalt())
3370 {
3371 error = HaltForDestroyOrDetach (exit_event_sp);
3372 if (!error.Success())
3373 {
3374 m_destroy_in_process = false;
3375 return error;
3376 }
3377 else if (exit_event_sp)
3378 {
3379 // We shouldn't need to do anything else here. There's no process left to detach from...
3380 StopPrivateStateThread();
3381 m_destroy_in_process = false;
3382 return error;
3383 }
3384 }
3385
Andrew MacPhersonc3826b52014-03-25 19:59:36 +00003386 m_thread_list.DiscardThreadPlans();
3387 DisableAllBreakpointSites();
3388
Jim Inghamacff8952013-05-02 00:27:30 +00003389 error = DoDetach(keep_stopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003390 if (error.Success())
3391 {
3392 DidDetach();
3393 StopPrivateStateThread();
3394 }
Jim Inghamacff8952013-05-02 00:27:30 +00003395 else
3396 {
3397 return error;
3398 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003399 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003400 m_destroy_in_process = false;
3401
3402 // If we exited when we were waiting for a process to stop, then
3403 // forward the event here so we don't lose the event
3404 if (exit_event_sp)
3405 {
3406 // Directly broadcast our exited event because we shut down our
3407 // private state thread above
3408 BroadcastEvent(exit_event_sp);
3409 }
3410
3411 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3412 // the last events through the event system, in which case we might strand the write lock. Unlock
3413 // it here so when we do to tear down the process we don't get an error destroying the lock.
3414
Ed Maste64fad602013-07-29 20:58:06 +00003415 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003416 return error;
3417}
3418
3419Error
3420Process::Destroy ()
3421{
Jim Ingham09437922013-03-01 20:04:25 +00003422
3423 // Tell ourselves we are in the process of destroying the process, so that we don't do any unnecessary work
3424 // that might hinder the destruction. Remember to set this back to false when we are done. That way if the attempt
3425 // failed and the process stays around for some reason it won't be in a confused state.
3426
3427 m_destroy_in_process = true;
3428
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003429 Error error (WillDestroy());
3430 if (error.Success())
3431 {
Greg Clayton85fb1b92012-09-11 02:33:37 +00003432 EventSP exit_event_sp;
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003433 if (DestroyRequiresHalt())
Jim Ingham04e0a222012-05-23 15:46:31 +00003434 {
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003435 error = HaltForDestroyOrDetach(exit_event_sp);
Jim Ingham04e0a222012-05-23 15:46:31 +00003436 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003437
Jim Inghamaacc3182012-06-06 00:29:30 +00003438 if (m_public_state.GetValue() != eStateRunning)
3439 {
3440 // Ditch all thread plans, and remove all our breakpoints: in case we have to restart the target to
3441 // kill it, we don't want it hitting a breakpoint...
3442 // Only do this if we've stopped, however, since if we didn't manage to halt it above, then
3443 // we're not going to have much luck doing this now.
3444 m_thread_list.DiscardThreadPlans();
3445 DisableAllBreakpointSites();
3446 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003447
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003448 error = DoDestroy();
3449 if (error.Success())
3450 {
3451 DidDestroy();
3452 StopPrivateStateThread();
3453 }
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003454 m_stdio_communication.StopReadThread();
3455 m_stdio_communication.Disconnect();
Greg Claytonb4874f12014-02-28 18:22:24 +00003456
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003457 if (m_process_input_reader)
Greg Claytonb4874f12014-02-28 18:22:24 +00003458 {
3459 m_process_input_reader->SetIsDone(true);
3460 m_process_input_reader->Cancel();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003461 m_process_input_reader.reset();
Greg Claytonb4874f12014-02-28 18:22:24 +00003462 }
3463
Greg Clayton85fb1b92012-09-11 02:33:37 +00003464 // If we exited when we were waiting for a process to stop, then
3465 // forward the event here so we don't lose the event
3466 if (exit_event_sp)
3467 {
3468 // Directly broadcast our exited event because we shut down our
3469 // private state thread above
3470 BroadcastEvent(exit_event_sp);
3471 }
3472
Jim Inghamb1e2e842012-04-12 18:49:31 +00003473 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3474 // the last events through the event system, in which case we might strand the write lock. Unlock
3475 // it here so when we do to tear down the process we don't get an error destroying the lock.
Ed Maste64fad602013-07-29 20:58:06 +00003476 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003477 }
Jim Ingham09437922013-03-01 20:04:25 +00003478
3479 m_destroy_in_process = false;
3480
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003481 return error;
3482}
3483
3484Error
3485Process::Signal (int signal)
3486{
3487 Error error (WillSignal());
3488 if (error.Success())
3489 {
3490 error = DoSignal(signal);
3491 if (error.Success())
3492 DidSignal();
3493 }
3494 return error;
3495}
3496
Greg Clayton514487e2011-02-15 21:59:32 +00003497lldb::ByteOrder
3498Process::GetByteOrder () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003499{
Greg Clayton514487e2011-02-15 21:59:32 +00003500 return m_target.GetArchitecture().GetByteOrder();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003501}
3502
3503uint32_t
Greg Clayton514487e2011-02-15 21:59:32 +00003504Process::GetAddressByteSize () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003505{
Greg Clayton514487e2011-02-15 21:59:32 +00003506 return m_target.GetArchitecture().GetAddressByteSize();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003507}
3508
Greg Clayton514487e2011-02-15 21:59:32 +00003509
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003510bool
3511Process::ShouldBroadcastEvent (Event *event_ptr)
3512{
3513 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr);
3514 bool return_value = true;
Greg Clayton5160ce52013-03-27 23:08:40 +00003515 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS | LIBLLDB_LOG_PROCESS));
Jim Ingham0161b492013-02-09 01:29:05 +00003516
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003517 switch (state)
3518 {
Greg Claytonb766a732011-02-04 01:58:07 +00003519 case eStateConnected:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003520 case eStateAttaching:
3521 case eStateLaunching:
3522 case eStateDetached:
3523 case eStateExited:
3524 case eStateUnloaded:
3525 // These events indicate changes in the state of the debugging session, always report them.
3526 return_value = true;
3527 break;
3528 case eStateInvalid:
3529 // We stopped for no apparent reason, don't report it.
3530 return_value = false;
3531 break;
3532 case eStateRunning:
3533 case eStateStepping:
3534 // If we've started the target running, we handle the cases where we
3535 // are already running and where there is a transition from stopped to
3536 // running differently.
3537 // running -> running: Automatically suppress extra running events
3538 // stopped -> running: Report except when there is one or more no votes
3539 // and no yes votes.
3540 SynchronouslyNotifyStateChanged (state);
Jim Ingham1460e4b2014-01-10 23:46:59 +00003541 if (m_force_next_event_delivery)
3542 return_value = true;
3543 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003544 {
Jim Ingham1460e4b2014-01-10 23:46:59 +00003545 switch (m_last_broadcast_state)
3546 {
3547 case eStateRunning:
3548 case eStateStepping:
3549 // We always suppress multiple runnings with no PUBLIC stop in between.
3550 return_value = false;
3551 break;
3552 default:
3553 // TODO: make this work correctly. For now always report
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00003554 // run if we aren't running so we don't miss any running
Jim Ingham1460e4b2014-01-10 23:46:59 +00003555 // events. If I run the lldb/test/thread/a.out file and
3556 // break at main.cpp:58, run and hit the breakpoints on
3557 // multiple threads, then somehow during the stepping over
3558 // of all breakpoints no run gets reported.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003559
Jim Ingham1460e4b2014-01-10 23:46:59 +00003560 // This is a transition from stop to run.
3561 switch (m_thread_list.ShouldReportRun (event_ptr))
3562 {
3563 case eVoteYes:
3564 case eVoteNoOpinion:
3565 return_value = true;
3566 break;
3567 case eVoteNo:
3568 return_value = false;
3569 break;
3570 }
3571 break;
3572 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003573 }
3574 break;
3575 case eStateStopped:
3576 case eStateCrashed:
3577 case eStateSuspended:
3578 {
3579 // We've stopped. First see if we're going to restart the target.
3580 // If we are going to stop, then we always broadcast the event.
3581 // If we aren't going to stop, let the thread plans decide if we're going to report this event.
Jim Inghamb01e7422010-06-19 04:45:32 +00003582 // If no thread has an opinion, we don't report it.
Jim Ingham221d51c2013-05-08 00:35:16 +00003583
Jim Inghamcb4ca112012-05-16 01:32:14 +00003584 RefreshStateAfterStop ();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003585 if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003586 {
Greg Clayton3af9ea52010-11-18 05:57:03 +00003587 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003588 log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003589 static_cast<void*>(event_ptr),
Jim Ingham0161b492013-02-09 01:29:05 +00003590 StateAsCString(state));
Jim Ingham35878c42014-04-08 21:33:21 +00003591 // Even though we know we are going to stop, we should let the threads have a look at the stop,
3592 // so they can properly set their state.
3593 m_thread_list.ShouldStop (event_ptr);
Jim Ingham0161b492013-02-09 01:29:05 +00003594 return_value = true;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003595 }
3596 else
3597 {
Jim Ingham221d51c2013-05-08 00:35:16 +00003598 bool was_restarted = ProcessEventData::GetRestartedFromEvent (event_ptr);
3599 bool should_resume = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003600
Jim Ingham0161b492013-02-09 01:29:05 +00003601 // It makes no sense to ask "ShouldStop" if we've already been restarted...
3602 // Asking the thread list is also not likely to go well, since we are running again.
3603 // So in that case just report the event.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003604
Jim Ingham0161b492013-02-09 01:29:05 +00003605 if (!was_restarted)
3606 should_resume = m_thread_list.ShouldStop (event_ptr) == false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003607
Jim Ingham221d51c2013-05-08 00:35:16 +00003608 if (was_restarted || should_resume || m_resume_requested)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003609 {
Jim Ingham0161b492013-02-09 01:29:05 +00003610 Vote stop_vote = m_thread_list.ShouldReportStop (event_ptr);
3611 if (log)
3612 log->Printf ("Process::ShouldBroadcastEvent: should_stop: %i state: %s was_restarted: %i stop_vote: %d.",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003613 should_resume, StateAsCString(state),
3614 was_restarted, stop_vote);
3615
Jim Ingham0161b492013-02-09 01:29:05 +00003616 switch (stop_vote)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003617 {
3618 case eVoteYes:
Jim Ingham0161b492013-02-09 01:29:05 +00003619 return_value = true;
3620 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003621 case eVoteNoOpinion:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003622 case eVoteNo:
3623 return_value = false;
3624 break;
3625 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003626
Jim Inghamcb95f342012-09-05 21:13:56 +00003627 if (!was_restarted)
Jim Ingham0161b492013-02-09 01:29:05 +00003628 {
3629 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003630 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s",
3631 static_cast<void*>(event_ptr),
3632 StateAsCString(state));
Jim Ingham0161b492013-02-09 01:29:05 +00003633 ProcessEventData::SetRestartedInEvent(event_ptr, true);
Jim Inghamcb95f342012-09-05 21:13:56 +00003634 PrivateResume ();
Jim Ingham0161b492013-02-09 01:29:05 +00003635 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003636
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003637 }
3638 else
3639 {
3640 return_value = true;
3641 SynchronouslyNotifyStateChanged (state);
3642 }
3643 }
3644 }
Jim Ingham0161b492013-02-09 01:29:05 +00003645 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003646 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003647
Jim Ingham1460e4b2014-01-10 23:46:59 +00003648 // Forcing the next event delivery is a one shot deal. So reset it here.
3649 m_force_next_event_delivery = false;
3650
Jim Ingham0161b492013-02-09 01:29:05 +00003651 // We do some coalescing of events (for instance two consecutive running events get coalesced.)
3652 // But we only coalesce against events we actually broadcast. So we use m_last_broadcast_state
3653 // to track that. NB - you can't use "m_public_state.GetValue()" for that purpose, as was originally done,
3654 // because the PublicState reflects the last event pulled off the queue, and there may be several
3655 // events stacked up on the queue unserviced. So the PublicState may not reflect the last broadcasted event
3656 // yet. m_last_broadcast_state gets updated here.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003657
Jim Ingham0161b492013-02-09 01:29:05 +00003658 if (return_value)
3659 m_last_broadcast_state = state;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003660
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003661 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003662 log->Printf ("Process::ShouldBroadcastEvent (%p) => new state: %s, last broadcast state: %s - %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003663 static_cast<void*>(event_ptr), StateAsCString(state),
Jim Ingham0161b492013-02-09 01:29:05 +00003664 StateAsCString(m_last_broadcast_state),
3665 return_value ? "YES" : "NO");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003666 return return_value;
3667}
3668
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003669
3670bool
Jim Ingham372787f2012-04-07 00:00:41 +00003671Process::StartPrivateStateThread (bool force)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003672{
Greg Clayton5160ce52013-03-27 23:08:40 +00003673 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003674
Greg Clayton8b82f082011-04-12 05:54:46 +00003675 bool already_running = PrivateStateThreadIsValid ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003676 if (log)
Greg Clayton8b82f082011-04-12 05:54:46 +00003677 log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread");
3678
Jim Ingham372787f2012-04-07 00:00:41 +00003679 if (!force && already_running)
Greg Clayton8b82f082011-04-12 05:54:46 +00003680 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003681
3682 // Create a thread that watches our internal state and controls which
3683 // events make it to clients (into the DCProcess event queue).
Greg Clayton3e06bd92011-01-09 21:07:35 +00003684 char thread_name[1024];
Todd Fiala17096d72014-07-16 19:03:16 +00003685
3686 if (Host::MAX_THREAD_NAME_LENGTH <= 16)
3687 {
3688 // On platforms with abbreviated thread name lengths, choose thread names that fit within the limit.
3689 if (already_running)
3690 snprintf(thread_name, sizeof(thread_name), "intern-state-OV");
3691 else
3692 snprintf(thread_name, sizeof(thread_name), "intern-state");
3693 }
Jim Ingham372787f2012-04-07 00:00:41 +00003694 else
Todd Fiala17096d72014-07-16 19:03:16 +00003695 {
3696 if (already_running)
3697 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state-override(pid=%" PRIu64 ")>", GetID());
3698 else
3699 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
3700 }
3701
Jim Ingham076b3042012-04-10 01:21:57 +00003702 // Create the private state thread, and start it running.
Greg Clayton3e06bd92011-01-09 21:07:35 +00003703 m_private_state_thread = Host::ThreadCreate (thread_name, Process::PrivateStateThread, this, NULL);
Jim Ingham076b3042012-04-10 01:21:57 +00003704 bool success = IS_VALID_LLDB_HOST_THREAD(m_private_state_thread);
3705 if (success)
3706 {
3707 ResumePrivateStateThread();
3708 return true;
3709 }
3710 else
3711 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003712}
3713
3714void
3715Process::PausePrivateStateThread ()
3716{
3717 ControlPrivateStateThread (eBroadcastInternalStateControlPause);
3718}
3719
3720void
3721Process::ResumePrivateStateThread ()
3722{
3723 ControlPrivateStateThread (eBroadcastInternalStateControlResume);
3724}
3725
3726void
3727Process::StopPrivateStateThread ()
3728{
Greg Clayton8b82f082011-04-12 05:54:46 +00003729 if (PrivateStateThreadIsValid ())
3730 ControlPrivateStateThread (eBroadcastInternalStateControlStop);
Jim Inghamb1e2e842012-04-12 18:49:31 +00003731 else
3732 {
Greg Clayton5160ce52013-03-27 23:08:40 +00003733 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Jim Inghamb1e2e842012-04-12 18:49:31 +00003734 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003735 log->Printf ("Went to stop the private state thread, but it was already invalid.");
Jim Inghamb1e2e842012-04-12 18:49:31 +00003736 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003737}
3738
3739void
3740Process::ControlPrivateStateThread (uint32_t signal)
3741{
Greg Clayton5160ce52013-03-27 23:08:40 +00003742 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003743
3744 assert (signal == eBroadcastInternalStateControlStop ||
3745 signal == eBroadcastInternalStateControlPause ||
3746 signal == eBroadcastInternalStateControlResume);
3747
3748 if (log)
Greg Clayton7ecb3a02011-01-22 17:43:17 +00003749 log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003750
Greg Clayton7ecb3a02011-01-22 17:43:17 +00003751 // Signal the private state thread. First we should copy this is case the
3752 // thread starts exiting since the private state thread will NULL this out
3753 // when it exits
3754 const lldb::thread_t private_state_thread = m_private_state_thread;
Greg Clayton2da6d492011-02-08 01:34:25 +00003755 if (IS_VALID_LLDB_HOST_THREAD(private_state_thread))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003756 {
3757 TimeValue timeout_time;
3758 bool timed_out;
3759
3760 m_private_state_control_broadcaster.BroadcastEvent (signal, NULL);
3761
3762 timeout_time = TimeValue::Now();
3763 timeout_time.OffsetWithSeconds(2);
Jim Inghamb1e2e842012-04-12 18:49:31 +00003764 if (log)
3765 log->Printf ("Sending control event of type: %d.", signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003766 m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out);
3767 m_private_state_control_wait.SetValue (false, eBroadcastNever);
3768
3769 if (signal == eBroadcastInternalStateControlStop)
3770 {
3771 if (timed_out)
Jim Inghamb1e2e842012-04-12 18:49:31 +00003772 {
3773 Error error;
3774 Host::ThreadCancel (private_state_thread, &error);
3775 if (log)
3776 log->Printf ("Timed out responding to the control event, cancel got error: \"%s\".", error.AsCString());
3777 }
3778 else
3779 {
3780 if (log)
3781 log->Printf ("The control event killed the private state thread without having to cancel.");
3782 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003783
3784 thread_result_t result = NULL;
Greg Clayton7ecb3a02011-01-22 17:43:17 +00003785 Host::ThreadJoin (private_state_thread, &result, NULL);
Greg Clayton49182ed2010-07-22 18:34:21 +00003786 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003787 }
3788 }
Jim Inghamb1e2e842012-04-12 18:49:31 +00003789 else
3790 {
3791 if (log)
3792 log->Printf ("Private state thread already dead, no need to signal it to stop.");
3793 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003794}
3795
3796void
Jim Inghamcfc09352012-07-27 23:57:19 +00003797Process::SendAsyncInterrupt ()
3798{
3799 if (PrivateStateThreadIsValid())
3800 m_private_state_broadcaster.BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
3801 else
3802 BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
3803}
3804
3805void
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003806Process::HandlePrivateEvent (EventSP &event_sp)
3807{
Greg Clayton5160ce52013-03-27 23:08:40 +00003808 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Ingham221d51c2013-05-08 00:35:16 +00003809 m_resume_requested = false;
3810
Jim Inghamaacc3182012-06-06 00:29:30 +00003811 m_currently_handling_event.SetValue(true, eBroadcastNever);
Jim Inghambb3a2832011-01-29 01:49:25 +00003812
Greg Clayton414f5d32011-01-25 02:58:48 +00003813 const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00003814
3815 // First check to see if anybody wants a shot at this event:
Jim Ingham754ab982011-01-29 04:05:41 +00003816 if (m_next_event_action_ap.get() != NULL)
Jim Inghambb3a2832011-01-29 01:49:25 +00003817 {
Jim Ingham754ab982011-01-29 04:05:41 +00003818 NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp);
Jim Ingham0161b492013-02-09 01:29:05 +00003819 if (log)
3820 log->Printf ("Ran next event action, result was %d.", action_result);
3821
Jim Inghambb3a2832011-01-29 01:49:25 +00003822 switch (action_result)
3823 {
3824 case NextEventAction::eEventActionSuccess:
3825 SetNextEventAction(NULL);
3826 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00003827
Jim Inghambb3a2832011-01-29 01:49:25 +00003828 case NextEventAction::eEventActionRetry:
3829 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00003830
Jim Inghambb3a2832011-01-29 01:49:25 +00003831 case NextEventAction::eEventActionExit:
Jim Ingham2a5fdd42011-01-29 01:57:31 +00003832 // Handle Exiting Here. If we already got an exited event,
3833 // we should just propagate it. Otherwise, swallow this event,
3834 // and set our state to exit so the next event will kill us.
3835 if (new_state != eStateExited)
3836 {
3837 // FIXME: should cons up an exited event, and discard this one.
Jim Ingham754ab982011-01-29 04:05:41 +00003838 SetExitStatus(0, m_next_event_action_ap->GetExitString());
Jim Ingham221d51c2013-05-08 00:35:16 +00003839 m_currently_handling_event.SetValue(false, eBroadcastAlways);
Jim Ingham2a5fdd42011-01-29 01:57:31 +00003840 SetNextEventAction(NULL);
3841 return;
3842 }
3843 SetNextEventAction(NULL);
Jim Inghambb3a2832011-01-29 01:49:25 +00003844 break;
3845 }
3846 }
3847
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003848 // See if we should broadcast this state to external clients?
3849 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003850
3851 if (should_broadcast)
3852 {
Greg Claytonb4874f12014-02-28 18:22:24 +00003853 const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003854 if (log)
3855 {
Daniel Malead01b2952012-11-29 21:49:15 +00003856 log->Printf ("Process::%s (pid = %" PRIu64 ") broadcasting new state %s (old state %s) to %s",
Greg Clayton414f5d32011-01-25 02:58:48 +00003857 __FUNCTION__,
3858 GetID(),
3859 StateAsCString(new_state),
3860 StateAsCString (GetState ()),
Greg Claytonb4874f12014-02-28 18:22:24 +00003861 is_hijacked ? "hijacked" : "public");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003862 }
Jim Ingham9575d842011-03-11 03:53:59 +00003863 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
Greg Clayton414f5d32011-01-25 02:58:48 +00003864 if (StateIsRunningState (new_state))
Greg Clayton44d93782014-01-27 23:43:24 +00003865 {
3866 // Only push the input handler if we aren't fowarding events,
3867 // as this means the curses GUI is in use...
3868 if (!GetTarget().GetDebugger().IsForwardingEvents())
3869 PushProcessIOHandler ();
3870 }
Greg Claytonb4874f12014-02-28 18:22:24 +00003871 else if (StateIsStoppedState(new_state, false))
3872 {
3873 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
3874 {
3875 // If the lldb_private::Debugger is handling the events, we don't
3876 // want to pop the process IOHandler here, we want to do it when
3877 // we receive the stopped event so we can carefully control when
3878 // the process IOHandler is popped because when we stop we want to
3879 // display some text stating how and why we stopped, then maybe some
3880 // process/thread/frame info, and then we want the "(lldb) " prompt
3881 // to show up. If we pop the process IOHandler here, then we will
3882 // cause the command interpreter to become the top IOHandler after
3883 // the process pops off and it will update its prompt right away...
3884 // See the Debugger.cpp file where it calls the function as
3885 // "process_sp->PopProcessIOHandler()" to see where I am talking about.
3886 // Otherwise we end up getting overlapping "(lldb) " prompts and
3887 // garbled output.
3888 //
3889 // If we aren't handling the events in the debugger (which is indicated
3890 // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or we
3891 // are hijacked, then we always pop the process IO handler manually.
3892 // Hijacking happens when the internal process state thread is running
3893 // thread plans, or when commands want to run in synchronous mode
3894 // and they call "process->WaitForProcessToStop()". An example of something
3895 // that will hijack the events is a simple expression:
3896 //
3897 // (lldb) expr (int)puts("hello")
3898 //
3899 // This will cause the internal process state thread to resume and halt
3900 // the process (and _it_ will hijack the eBroadcastBitStateChanged
3901 // events) and we do need the IO handler to be pushed and popped
3902 // correctly.
3903
3904 if (is_hijacked || m_target.GetDebugger().IsHandlingEvents() == false)
3905 PopProcessIOHandler ();
3906 }
3907 }
Jim Ingham9575d842011-03-11 03:53:59 +00003908
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003909 BroadcastEvent (event_sp);
3910 }
3911 else
3912 {
3913 if (log)
3914 {
Daniel Malead01b2952012-11-29 21:49:15 +00003915 log->Printf ("Process::%s (pid = %" PRIu64 ") suppressing state %s (old state %s): should_broadcast == false",
Greg Clayton414f5d32011-01-25 02:58:48 +00003916 __FUNCTION__,
3917 GetID(),
3918 StateAsCString(new_state),
Jason Molendafd54b362011-09-20 21:44:10 +00003919 StateAsCString (GetState ()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003920 }
3921 }
Jim Inghamaacc3182012-06-06 00:29:30 +00003922 m_currently_handling_event.SetValue(false, eBroadcastAlways);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003923}
3924
Virgile Bellob2f1fb22013-08-23 12:44:05 +00003925thread_result_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003926Process::PrivateStateThread (void *arg)
3927{
3928 Process *proc = static_cast<Process*> (arg);
Virgile Bellob2f1fb22013-08-23 12:44:05 +00003929 thread_result_t result = proc->RunPrivateStateThread();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003930 return result;
3931}
3932
Virgile Bellob2f1fb22013-08-23 12:44:05 +00003933thread_result_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003934Process::RunPrivateStateThread ()
3935{
Jim Ingham076b3042012-04-10 01:21:57 +00003936 bool control_only = true;
Jim Inghamb1e2e842012-04-12 18:49:31 +00003937 m_private_state_control_wait.SetValue (false, eBroadcastNever);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003938
Greg Clayton5160ce52013-03-27 23:08:40 +00003939 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003940 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003941 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
3942 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003943
3944 bool exit_now = false;
3945 while (!exit_now)
3946 {
3947 EventSP event_sp;
3948 WaitForEventsPrivate (NULL, event_sp, control_only);
3949 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
3950 {
Jim Inghamb1e2e842012-04-12 18:49:31 +00003951 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003952 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") got a control event: %d",
3953 __FUNCTION__, static_cast<void*>(this), GetID(),
3954 event_sp->GetType());
Jim Inghamb1e2e842012-04-12 18:49:31 +00003955
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003956 switch (event_sp->GetType())
3957 {
3958 case eBroadcastInternalStateControlStop:
3959 exit_now = true;
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00003960 break; // doing any internal state management below
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003961
3962 case eBroadcastInternalStateControlPause:
3963 control_only = true;
3964 break;
3965
3966 case eBroadcastInternalStateControlResume:
3967 control_only = false;
3968 break;
3969 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003970
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003971 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003972 continue;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003973 }
Jim Inghamcfc09352012-07-27 23:57:19 +00003974 else if (event_sp->GetType() == eBroadcastBitInterrupt)
3975 {
3976 if (m_public_state.GetValue() == eStateAttaching)
3977 {
3978 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003979 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt while attaching - forwarding interrupt.",
3980 __FUNCTION__, static_cast<void*>(this),
3981 GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00003982 BroadcastEvent (eBroadcastBitInterrupt, NULL);
3983 }
3984 else
3985 {
3986 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003987 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt - Halting.",
3988 __FUNCTION__, static_cast<void*>(this),
3989 GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00003990 Halt();
3991 }
3992 continue;
3993 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003994
3995 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3996
3997 if (internal_state != eStateInvalid)
3998 {
Greg Claytonf9b57b92013-05-10 23:48:10 +00003999 if (m_clear_thread_plans_on_stop &&
4000 StateIsStoppedState(internal_state, true))
4001 {
4002 m_clear_thread_plans_on_stop = false;
4003 m_thread_list.DiscardThreadPlans();
4004 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004005 HandlePrivateEvent (event_sp);
4006 }
4007
Greg Clayton58d1c9a2010-10-18 04:14:23 +00004008 if (internal_state == eStateInvalid ||
4009 internal_state == eStateExited ||
4010 internal_state == eStateDetached )
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004011 {
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004012 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004013 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") about to exit with internal state %s...",
4014 __FUNCTION__, static_cast<void*>(this), GetID(),
4015 StateAsCString(internal_state));
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004016
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004017 break;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004018 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004019 }
4020
Caroline Tice20ad3c42010-10-29 21:48:37 +00004021 // Verify log is still enabled before attempting to write to it...
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004022 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004023 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
4024 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004025
Ed Maste64fad602013-07-29 20:58:06 +00004026 m_public_run_lock.SetStopped();
Greg Clayton6ed95942011-01-22 07:12:45 +00004027 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
4028 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004029 return NULL;
4030}
4031
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004032//------------------------------------------------------------------
4033// Process Event Data
4034//------------------------------------------------------------------
4035
4036Process::ProcessEventData::ProcessEventData () :
4037 EventData (),
4038 m_process_sp (),
4039 m_state (eStateInvalid),
Greg Claytonc982c762010-07-09 20:39:50 +00004040 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004041 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004042 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004043{
4044}
4045
4046Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) :
4047 EventData (),
4048 m_process_sp (process_sp),
4049 m_state (state),
Greg Claytonc982c762010-07-09 20:39:50 +00004050 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004051 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004052 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004053{
4054}
4055
4056Process::ProcessEventData::~ProcessEventData()
4057{
4058}
4059
4060const ConstString &
4061Process::ProcessEventData::GetFlavorString ()
4062{
4063 static ConstString g_flavor ("Process::ProcessEventData");
4064 return g_flavor;
4065}
4066
4067const ConstString &
4068Process::ProcessEventData::GetFlavor () const
4069{
4070 return ProcessEventData::GetFlavorString ();
4071}
4072
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004073void
4074Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
4075{
4076 // This function gets called twice for each event, once when the event gets pulled
Jim Inghama8604692011-05-22 21:45:01 +00004077 // off of the private process event queue, and then any number of times, first when it gets pulled off of
4078 // the public event queue, then other times when we're pretending that this is where we stopped at the
4079 // end of expression evaluation. m_update_state is used to distinguish these
4080 // three cases; it is 0 when we're just pulling it off for private handling,
Jim Ingham221d51c2013-05-08 00:35:16 +00004081 // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
Jim Inghama8604692011-05-22 21:45:01 +00004082 if (m_update_state != 1)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004083 return;
Jim Ingham0161b492013-02-09 01:29:05 +00004084
Jim Ingham221d51c2013-05-08 00:35:16 +00004085 m_process_sp->SetPublicState (m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
Jim Ingham35878c42014-04-08 21:33:21 +00004086
4087 // If this is a halt event, even if the halt stopped with some reason other than a plain interrupt (e.g. we had
4088 // already stopped for a breakpoint when the halt request came through) don't do the StopInfo actions, as they may
4089 // end up restarting the process.
4090 if (m_interrupted)
4091 return;
4092
4093 // If we're stopped and haven't restarted, then do the StopInfo actions here:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004094 if (m_state == eStateStopped && ! m_restarted)
Jim Ingham0faa43f2011-11-08 03:00:11 +00004095 {
4096 ThreadList &curr_thread_list = m_process_sp->GetThreadList();
Greg Clayton61e7a582011-12-01 23:28:38 +00004097 uint32_t num_threads = curr_thread_list.GetSize();
4098 uint32_t idx;
Greg Claytonf4b47e12010-08-04 01:40:35 +00004099
Jim Ingham4b536182011-08-09 02:12:22 +00004100 // The actions might change one of the thread's stop_info's opinions about whether we should
4101 // stop the process, so we need to query that as we go.
Jim Ingham0faa43f2011-11-08 03:00:11 +00004102
4103 // One other complication here, is that we try to catch any case where the target has run (except for expressions)
4104 // and immediately exit, but if we get that wrong (which is possible) then the thread list might have changed, and
4105 // that would cause our iteration here to crash. We could make a copy of the thread list, but we'd really like
4106 // to also know if it has changed at all, so we make up a vector of the thread ID's and check what we get back
4107 // against this list & bag out if anything differs.
Greg Clayton61e7a582011-12-01 23:28:38 +00004108 std::vector<uint32_t> thread_index_array(num_threads);
Jim Ingham0faa43f2011-11-08 03:00:11 +00004109 for (idx = 0; idx < num_threads; ++idx)
4110 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
4111
Jim Inghamc7078c22012-12-13 22:24:15 +00004112 // Use this to track whether we should continue from here. We will only continue the target running if
4113 // no thread says we should stop. Of course if some thread's PerformAction actually sets the target running,
4114 // then it doesn't matter what the other threads say...
4115
4116 bool still_should_stop = false;
Jim Ingham4b536182011-08-09 02:12:22 +00004117
Jim Ingham0ad7e052013-04-25 02:04:59 +00004118 // Sometimes - for instance if we have a bug in the stub we are talking to, we stop but no thread has a
4119 // valid stop reason. In that case we should just stop, because we have no way of telling what the right
4120 // thing to do is, and it's better to let the user decide than continue behind their backs.
4121
4122 bool does_anybody_have_an_opinion = false;
4123
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004124 for (idx = 0; idx < num_threads; ++idx)
4125 {
Jim Ingham0faa43f2011-11-08 03:00:11 +00004126 curr_thread_list = m_process_sp->GetThreadList();
4127 if (curr_thread_list.GetSize() != num_threads)
4128 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004129 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004130 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004131 log->Printf("Number of threads changed from %u to %u while processing event.", num_threads, curr_thread_list.GetSize());
Jim Ingham0faa43f2011-11-08 03:00:11 +00004132 break;
4133 }
4134
4135 lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
4136
4137 if (thread_sp->GetIndexID() != thread_index_array[idx])
4138 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004139 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004140 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004141 log->Printf("The thread at position %u changed from %u to %u while processing event.",
Jim Ingham87c665f2011-12-01 20:26:15 +00004142 idx,
4143 thread_index_array[idx],
4144 thread_sp->GetIndexID());
Jim Ingham0faa43f2011-11-08 03:00:11 +00004145 break;
4146 }
4147
Jim Inghamb15bfc72010-10-20 00:39:53 +00004148 StopInfoSP stop_info_sp = thread_sp->GetStopInfo ();
Jim Ingham5d88a062012-10-16 00:09:33 +00004149 if (stop_info_sp && stop_info_sp->IsValid())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004150 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004151 does_anybody_have_an_opinion = true;
Jim Ingham0161b492013-02-09 01:29:05 +00004152 bool this_thread_wants_to_stop;
4153 if (stop_info_sp->GetOverrideShouldStop())
Jim Ingham4b536182011-08-09 02:12:22 +00004154 {
Jim Ingham0161b492013-02-09 01:29:05 +00004155 this_thread_wants_to_stop = stop_info_sp->GetOverriddenShouldStopValue();
4156 }
4157 else
4158 {
4159 stop_info_sp->PerformAction(event_ptr);
4160 // The stop action might restart the target. If it does, then we want to mark that in the
4161 // event so that whoever is receiving it will know to wait for the running event and reflect
4162 // that state appropriately.
4163 // We also need to stop processing actions, since they aren't expecting the target to be running.
4164
4165 // FIXME: we might have run.
4166 if (stop_info_sp->HasTargetRunSinceMe())
4167 {
4168 SetRestarted (true);
4169 break;
4170 }
4171
4172 this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
Jim Ingham4b536182011-08-09 02:12:22 +00004173 }
Jim Inghamc7078c22012-12-13 22:24:15 +00004174
Jim Inghamc7078c22012-12-13 22:24:15 +00004175 if (still_should_stop == false)
4176 still_should_stop = this_thread_wants_to_stop;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004177 }
4178 }
Jim Ingham3ebcf7f2010-08-10 00:59:59 +00004179
Ashok Thirumurthicf7c55e2013-04-18 14:38:20 +00004180
Jim Inghama8ca6e22013-05-03 23:04:37 +00004181 if (!GetRestarted())
Jim Ingham9575d842011-03-11 03:53:59 +00004182 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004183 if (!still_should_stop && does_anybody_have_an_opinion)
Jim Ingham4b536182011-08-09 02:12:22 +00004184 {
4185 // We've been asked to continue, so do that here.
Jim Ingham9575d842011-03-11 03:53:59 +00004186 SetRestarted(true);
Jim Ingham3b8285d2012-04-19 01:40:33 +00004187 // Use the public resume method here, since this is just
4188 // extending a public resume.
Jim Ingham0161b492013-02-09 01:29:05 +00004189 m_process_sp->PrivateResume();
Jim Ingham4b536182011-08-09 02:12:22 +00004190 }
4191 else
4192 {
4193 // If we didn't restart, run the Stop Hooks here:
4194 // They might also restart the target, so watch for that.
4195 m_process_sp->GetTarget().RunStopHooks();
4196 if (m_process_sp->GetPrivateState() == eStateRunning)
4197 SetRestarted(true);
4198 }
Jim Ingham9575d842011-03-11 03:53:59 +00004199 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004200 }
4201}
4202
4203void
4204Process::ProcessEventData::Dump (Stream *s) const
4205{
4206 if (m_process_sp)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004207 s->Printf(" process = %p (pid = %" PRIu64 "), ",
4208 static_cast<void*>(m_process_sp.get()), m_process_sp->GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004209
Greg Clayton8b82f082011-04-12 05:54:46 +00004210 s->Printf("state = %s", StateAsCString(GetState()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004211}
4212
4213const Process::ProcessEventData *
4214Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr)
4215{
4216 if (event_ptr)
4217 {
4218 const EventData *event_data = event_ptr->GetData();
4219 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString())
4220 return static_cast <const ProcessEventData *> (event_ptr->GetData());
4221 }
4222 return NULL;
4223}
4224
4225ProcessSP
4226Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr)
4227{
4228 ProcessSP process_sp;
4229 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4230 if (data)
4231 process_sp = data->GetProcessSP();
4232 return process_sp;
4233}
4234
4235StateType
4236Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr)
4237{
4238 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4239 if (data == NULL)
4240 return eStateInvalid;
4241 else
4242 return data->GetState();
4243}
4244
4245bool
4246Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr)
4247{
4248 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4249 if (data == NULL)
4250 return false;
4251 else
4252 return data->GetRestarted();
4253}
4254
4255void
4256Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value)
4257{
4258 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4259 if (data != NULL)
4260 data->SetRestarted(new_value);
4261}
4262
Jim Ingham0161b492013-02-09 01:29:05 +00004263size_t
4264Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr)
4265{
4266 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4267 if (data != NULL)
4268 return data->GetNumRestartedReasons();
4269 else
4270 return 0;
4271}
4272
4273const char *
4274Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr, size_t idx)
4275{
4276 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4277 if (data != NULL)
4278 return data->GetRestartedReasonAtIndex(idx);
4279 else
4280 return NULL;
4281}
4282
4283void
4284Process::ProcessEventData::AddRestartedReason (Event *event_ptr, const char *reason)
4285{
4286 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4287 if (data != NULL)
4288 data->AddRestartedReason(reason);
4289}
4290
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004291bool
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004292Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr)
4293{
4294 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4295 if (data == NULL)
4296 return false;
4297 else
4298 return data->GetInterrupted ();
4299}
4300
4301void
4302Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value)
4303{
4304 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4305 if (data != NULL)
4306 data->SetInterrupted(new_value);
4307}
4308
4309bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004310Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr)
4311{
4312 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4313 if (data)
4314 {
4315 data->SetUpdateStateOnRemoval();
4316 return true;
4317 }
4318 return false;
4319}
4320
Greg Claytond9e416c2012-02-18 05:35:26 +00004321lldb::TargetSP
4322Process::CalculateTarget ()
4323{
4324 return m_target.shared_from_this();
4325}
4326
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004327void
Greg Clayton0603aa92010-10-04 01:05:56 +00004328Process::CalculateExecutionContext (ExecutionContext &exe_ctx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004329{
Greg Claytonc14ee322011-09-22 04:58:26 +00004330 exe_ctx.SetTargetPtr (&m_target);
4331 exe_ctx.SetProcessPtr (this);
4332 exe_ctx.SetThreadPtr(NULL);
4333 exe_ctx.SetFramePtr (NULL);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004334}
4335
Greg Claytone996fd32011-03-08 22:40:15 +00004336//uint32_t
4337//Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
4338//{
4339// return 0;
4340//}
4341//
4342//ArchSpec
4343//Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4344//{
4345// return Host::GetArchSpecForExistingProcess (pid);
4346//}
4347//
4348//ArchSpec
4349//Process::GetArchSpecForExistingProcess (const char *process_name)
4350//{
4351// return Host::GetArchSpecForExistingProcess (process_name);
4352//}
4353//
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004354void
4355Process::AppendSTDOUT (const char * s, size_t len)
4356{
Greg Clayton3af9ea52010-11-18 05:57:03 +00004357 Mutex::Locker locker (m_stdio_communication_mutex);
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004358 m_stdout_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004359 BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (shared_from_this(), GetState()));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004360}
4361
4362void
Greg Clayton93e86192011-11-13 04:45:22 +00004363Process::AppendSTDERR (const char * s, size_t len)
4364{
4365 Mutex::Locker locker (m_stdio_communication_mutex);
4366 m_stderr_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004367 BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (shared_from_this(), GetState()));
Greg Clayton93e86192011-11-13 04:45:22 +00004368}
4369
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004370void
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004371Process::BroadcastAsyncProfileData(const std::string &one_profile_data)
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004372{
4373 Mutex::Locker locker (m_profile_data_comm_mutex);
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004374 m_profile_data.push_back(one_profile_data);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004375 BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState()));
4376}
4377
4378size_t
4379Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
4380{
4381 Mutex::Locker locker(m_profile_data_comm_mutex);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004382 if (m_profile_data.empty())
4383 return 0;
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004384
4385 std::string &one_profile_data = m_profile_data.front();
4386 size_t bytes_available = one_profile_data.size();
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004387 if (bytes_available > 0)
4388 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004389 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004390 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004391 log->Printf ("Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4392 static_cast<void*>(buf),
4393 static_cast<uint64_t>(buf_size));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004394 if (bytes_available > buf_size)
4395 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004396 memcpy(buf, one_profile_data.c_str(), buf_size);
4397 one_profile_data.erase(0, buf_size);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004398 bytes_available = buf_size;
4399 }
4400 else
4401 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004402 memcpy(buf, one_profile_data.c_str(), bytes_available);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004403 m_profile_data.erase(m_profile_data.begin());
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004404 }
4405 }
4406 return bytes_available;
4407}
4408
4409
Greg Clayton93e86192011-11-13 04:45:22 +00004410//------------------------------------------------------------------
4411// Process STDIO
4412//------------------------------------------------------------------
4413
4414size_t
4415Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
4416{
4417 Mutex::Locker locker(m_stdio_communication_mutex);
4418 size_t bytes_available = m_stdout_data.size();
4419 if (bytes_available > 0)
4420 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004421 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004422 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004423 log->Printf ("Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4424 static_cast<void*>(buf),
4425 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004426 if (bytes_available > buf_size)
4427 {
4428 memcpy(buf, m_stdout_data.c_str(), buf_size);
4429 m_stdout_data.erase(0, buf_size);
4430 bytes_available = buf_size;
4431 }
4432 else
4433 {
4434 memcpy(buf, m_stdout_data.c_str(), bytes_available);
4435 m_stdout_data.clear();
4436 }
4437 }
4438 return bytes_available;
4439}
4440
4441
4442size_t
4443Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
4444{
4445 Mutex::Locker locker(m_stdio_communication_mutex);
4446 size_t bytes_available = m_stderr_data.size();
4447 if (bytes_available > 0)
4448 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004449 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004450 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004451 log->Printf ("Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4452 static_cast<void*>(buf),
4453 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004454 if (bytes_available > buf_size)
4455 {
4456 memcpy(buf, m_stderr_data.c_str(), buf_size);
4457 m_stderr_data.erase(0, buf_size);
4458 bytes_available = buf_size;
4459 }
4460 else
4461 {
4462 memcpy(buf, m_stderr_data.c_str(), bytes_available);
4463 m_stderr_data.clear();
4464 }
4465 }
4466 return bytes_available;
4467}
4468
4469void
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004470Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
4471{
4472 Process *process = (Process *) baton;
4473 process->AppendSTDOUT (static_cast<const char *>(src), src_len);
4474}
4475
Greg Clayton44d93782014-01-27 23:43:24 +00004476class IOHandlerProcessSTDIO :
4477 public IOHandler
4478{
4479public:
4480 IOHandlerProcessSTDIO (Process *process,
4481 int write_fd) :
4482 IOHandler(process->GetTarget().GetDebugger()),
4483 m_process (process),
4484 m_read_file (),
4485 m_write_file (write_fd, false),
Greg Clayton100eb932014-07-02 21:10:39 +00004486 m_pipe ()
Greg Clayton44d93782014-01-27 23:43:24 +00004487 {
4488 m_read_file.SetDescriptor(GetInputFD(), false);
4489 }
4490
4491 virtual
4492 ~IOHandlerProcessSTDIO ()
4493 {
4494
4495 }
4496
4497 bool
4498 OpenPipes ()
4499 {
Greg Clayton100eb932014-07-02 21:10:39 +00004500 if (m_pipe.IsValid())
Greg Clayton44d93782014-01-27 23:43:24 +00004501 return true;
Greg Clayton100eb932014-07-02 21:10:39 +00004502 return m_pipe.Open();
Greg Clayton44d93782014-01-27 23:43:24 +00004503 }
4504
4505 void
4506 ClosePipes()
4507 {
Greg Clayton100eb932014-07-02 21:10:39 +00004508 m_pipe.Close();
Greg Clayton44d93782014-01-27 23:43:24 +00004509 }
4510
4511 // Each IOHandler gets to run until it is done. It should read data
4512 // from the "in" and place output into "out" and "err and return
4513 // when done.
4514 virtual void
4515 Run ()
4516 {
4517 if (m_read_file.IsValid() && m_write_file.IsValid())
4518 {
4519 SetIsDone(false);
4520 if (OpenPipes())
4521 {
4522 const int read_fd = m_read_file.GetDescriptor();
Greg Clayton100eb932014-07-02 21:10:39 +00004523 const int pipe_read_fd = m_pipe.GetReadFileDescriptor();
Greg Clayton44d93782014-01-27 23:43:24 +00004524 TerminalState terminal_state;
4525 terminal_state.Save (read_fd, false);
4526 Terminal terminal(read_fd);
4527 terminal.SetCanonical(false);
4528 terminal.SetEcho(false);
Deepak Panickal914b8d92014-01-31 18:48:46 +00004529// FD_ZERO, FD_SET are not supported on windows
Hafiz Abid Qadeer6eff1012014-03-12 10:45:23 +00004530#ifndef _WIN32
Greg Clayton44d93782014-01-27 23:43:24 +00004531 while (!GetIsDone())
4532 {
4533 fd_set read_fdset;
4534 FD_ZERO (&read_fdset);
4535 FD_SET (read_fd, &read_fdset);
4536 FD_SET (pipe_read_fd, &read_fdset);
4537 const int nfds = std::max<int>(read_fd, pipe_read_fd) + 1;
4538 int num_set_fds = select (nfds, &read_fdset, NULL, NULL, NULL);
4539 if (num_set_fds < 0)
4540 {
4541 const int select_errno = errno;
4542
4543 if (select_errno != EINTR)
4544 SetIsDone(true);
4545 }
4546 else if (num_set_fds > 0)
4547 {
4548 char ch = 0;
4549 size_t n;
4550 if (FD_ISSET (read_fd, &read_fdset))
4551 {
4552 n = 1;
4553 if (m_read_file.Read(&ch, n).Success() && n == 1)
4554 {
4555 if (m_write_file.Write(&ch, n).Fail() || n != 1)
4556 SetIsDone(true);
4557 }
4558 else
4559 SetIsDone(true);
4560 }
4561 if (FD_ISSET (pipe_read_fd, &read_fdset))
4562 {
4563 // Consume the interrupt byte
Greg Clayton100eb932014-07-02 21:10:39 +00004564 if (m_pipe.Read (&ch, 1) == 1)
Greg Clayton19e11352014-02-26 22:47:33 +00004565 {
Greg Clayton100eb932014-07-02 21:10:39 +00004566 switch (ch)
4567 {
4568 case 'q':
4569 SetIsDone(true);
4570 break;
4571 case 'i':
4572 if (StateIsRunningState(m_process->GetState()))
4573 m_process->Halt();
4574 break;
4575 }
Greg Clayton19e11352014-02-26 22:47:33 +00004576 }
Greg Clayton44d93782014-01-27 23:43:24 +00004577 }
4578 }
4579 }
Deepak Panickal914b8d92014-01-31 18:48:46 +00004580#endif
Greg Clayton44d93782014-01-27 23:43:24 +00004581 terminal_state.Restore();
4582
4583 }
4584 else
4585 SetIsDone(true);
4586 }
4587 else
4588 SetIsDone(true);
4589 }
4590
4591 // Hide any characters that have been displayed so far so async
4592 // output can be displayed. Refresh() will be called after the
4593 // output has been displayed.
4594 virtual void
4595 Hide ()
4596 {
4597
4598 }
4599 // Called when the async output has been received in order to update
4600 // the input reader (refresh the prompt and redisplay any current
4601 // line(s) that are being edited
4602 virtual void
4603 Refresh ()
4604 {
4605
4606 }
Greg Claytone68f5d62014-02-24 22:50:57 +00004607
Greg Clayton44d93782014-01-27 23:43:24 +00004608 virtual void
Greg Claytone68f5d62014-02-24 22:50:57 +00004609 Cancel ()
Greg Clayton44d93782014-01-27 23:43:24 +00004610 {
Greg Clayton19e11352014-02-26 22:47:33 +00004611 char ch = 'q'; // Send 'q' for quit
Greg Clayton100eb932014-07-02 21:10:39 +00004612 m_pipe.Write (&ch, 1);
Greg Clayton44d93782014-01-27 23:43:24 +00004613 }
Greg Claytone68f5d62014-02-24 22:50:57 +00004614
Greg Claytonf0066ad2014-05-02 00:45:31 +00004615 virtual bool
Greg Claytone68f5d62014-02-24 22:50:57 +00004616 Interrupt ()
4617 {
Greg Clayton19e11352014-02-26 22:47:33 +00004618 // Do only things that are safe to do in an interrupt context (like in
4619 // a SIGINT handler), like write 1 byte to a file descriptor. This will
4620 // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
4621 // that was written to the pipe and then call m_process->Halt() from a
4622 // much safer location in code.
Greg Clayton0fdd3ae2014-07-16 21:05:41 +00004623 if (m_active)
4624 {
4625 char ch = 'i'; // Send 'i' for interrupt
4626 return m_pipe.Write (&ch, 1) == 1;
4627 }
4628 else
4629 {
4630 // This IOHandler might be pushed on the stack, but not being run currently
4631 // so do the right thing if we aren't actively watching for STDIN by sending
4632 // the interrupt to the process. Otherwise the write to the pipe above would
4633 // do nothing. This can happen when the command interpreter is running and
4634 // gets a "expression ...". It will be on the IOHandler thread and sending
4635 // the input is complete to the delegate which will cause the expression to
4636 // run, which will push the process IO handler, but not run it.
4637
4638 if (StateIsRunningState(m_process->GetState()))
4639 {
4640 m_process->SendAsyncInterrupt();
4641 return true;
4642 }
4643 }
4644 return false;
Greg Claytone68f5d62014-02-24 22:50:57 +00004645 }
Greg Clayton44d93782014-01-27 23:43:24 +00004646
4647 virtual void
4648 GotEOF()
4649 {
4650
4651 }
4652
4653protected:
4654 Process *m_process;
4655 File m_read_file; // Read from this file (usually actual STDIN for LLDB
4656 File m_write_file; // Write to this file (usually the master pty for getting io to debuggee)
Greg Clayton100eb932014-07-02 21:10:39 +00004657 Pipe m_pipe;
Greg Clayton44d93782014-01-27 23:43:24 +00004658};
4659
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004660void
Greg Clayton44d93782014-01-27 23:43:24 +00004661Process::SetSTDIOFileDescriptor (int fd)
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004662{
4663 // First set up the Read Thread for reading/handling process I/O
4664
Greg Clayton44d93782014-01-27 23:43:24 +00004665 std::unique_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (fd, true));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004666
4667 if (conn_ap.get())
4668 {
4669 m_stdio_communication.SetConnection (conn_ap.release());
4670 if (m_stdio_communication.IsConnected())
4671 {
4672 m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
4673 m_stdio_communication.StartReadThread();
4674
4675 // Now read thread is set up, set up input reader.
4676
4677 if (!m_process_input_reader.get())
Greg Clayton44d93782014-01-27 23:43:24 +00004678 m_process_input_reader.reset (new IOHandlerProcessSTDIO (this, fd));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004679 }
4680 }
4681}
4682
Greg Claytonb4874f12014-02-28 18:22:24 +00004683bool
Greg Clayton6fea17e2014-03-03 19:15:20 +00004684Process::ProcessIOHandlerIsActive ()
4685{
4686 IOHandlerSP io_handler_sp (m_process_input_reader);
4687 if (io_handler_sp)
4688 return m_target.GetDebugger().IsTopIOHandler (io_handler_sp);
4689 return false;
4690}
4691bool
Greg Clayton44d93782014-01-27 23:43:24 +00004692Process::PushProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004693{
Greg Clayton44d93782014-01-27 23:43:24 +00004694 IOHandlerSP io_handler_sp (m_process_input_reader);
4695 if (io_handler_sp)
4696 {
4697 io_handler_sp->SetIsDone(false);
4698 m_target.GetDebugger().PushIOHandler (io_handler_sp);
Greg Claytonb4874f12014-02-28 18:22:24 +00004699 return true;
Greg Clayton44d93782014-01-27 23:43:24 +00004700 }
Greg Claytonb4874f12014-02-28 18:22:24 +00004701 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004702}
4703
Greg Claytonb4874f12014-02-28 18:22:24 +00004704bool
Greg Clayton44d93782014-01-27 23:43:24 +00004705Process::PopProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004706{
Greg Clayton44d93782014-01-27 23:43:24 +00004707 IOHandlerSP io_handler_sp (m_process_input_reader);
4708 if (io_handler_sp)
Greg Claytonb4874f12014-02-28 18:22:24 +00004709 return m_target.GetDebugger().PopIOHandler (io_handler_sp);
4710 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004711}
4712
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00004713// The process needs to know about installed plug-ins
Greg Clayton99d0faf2010-11-18 23:32:35 +00004714void
Caroline Tice20bd37f2011-03-10 22:14:10 +00004715Process::SettingsInitialize ()
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004716{
Greg Clayton6920b522012-08-22 18:39:03 +00004717 Thread::SettingsInitialize ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00004718}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004719
Greg Clayton99d0faf2010-11-18 23:32:35 +00004720void
Caroline Tice20bd37f2011-03-10 22:14:10 +00004721Process::SettingsTerminate ()
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00004722{
Greg Clayton6920b522012-08-22 18:39:03 +00004723 Thread::SettingsTerminate ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00004724}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004725
Jim Ingham1624a2d2014-05-05 02:26:40 +00004726ExpressionResults
Jim Inghamf48169b2010-11-30 02:22:11 +00004727Process::RunThreadPlan (ExecutionContext &exe_ctx,
Jim Ingham372787f2012-04-07 00:00:41 +00004728 lldb::ThreadPlanSP &thread_plan_sp,
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004729 const EvaluateExpressionOptions &options,
Jim Inghamf48169b2010-11-30 02:22:11 +00004730 Stream &errors)
4731{
Jim Ingham8646d3c2014-05-05 02:47:44 +00004732 ExpressionResults return_value = eExpressionSetupError;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004733
Jim Ingham77787032011-01-20 02:03:18 +00004734 if (thread_plan_sp.get() == NULL)
4735 {
4736 errors.Printf("RunThreadPlan called with empty thread plan.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004737 return eExpressionSetupError;
Jim Ingham77787032011-01-20 02:03:18 +00004738 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004739
Jim Ingham7d7931d2013-03-28 00:05:34 +00004740 if (!thread_plan_sp->ValidatePlan(NULL))
4741 {
4742 errors.Printf ("RunThreadPlan called with an invalid thread plan.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004743 return eExpressionSetupError;
Jim Ingham7d7931d2013-03-28 00:05:34 +00004744 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004745
Greg Claytonc14ee322011-09-22 04:58:26 +00004746 if (exe_ctx.GetProcessPtr() != this)
4747 {
4748 errors.Printf("RunThreadPlan called on wrong process.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004749 return eExpressionSetupError;
Greg Claytonc14ee322011-09-22 04:58:26 +00004750 }
4751
4752 Thread *thread = exe_ctx.GetThreadPtr();
4753 if (thread == NULL)
4754 {
4755 errors.Printf("RunThreadPlan called with invalid thread.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004756 return eExpressionSetupError;
Greg Claytonc14ee322011-09-22 04:58:26 +00004757 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004758
Jim Ingham17e5c4e2011-05-17 22:24:54 +00004759 // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes.
4760 // For that to be true the plan can't be private - since private plans suppress themselves in the
4761 // GetCompletedPlan call.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004762
Jim Ingham17e5c4e2011-05-17 22:24:54 +00004763 bool orig_plan_private = thread_plan_sp->GetPrivate();
4764 thread_plan_sp->SetPrivate(false);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004765
Jim Ingham444586b2011-01-24 06:34:17 +00004766 if (m_private_state.GetValue() != eStateStopped)
4767 {
4768 errors.Printf ("RunThreadPlan called while the private state was not stopped.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004769 return eExpressionSetupError;
Jim Ingham444586b2011-01-24 06:34:17 +00004770 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004771
Jim Ingham66243842011-08-13 00:56:10 +00004772 // Save the thread & frame from the exe_ctx for restoration after we run
Greg Claytonc14ee322011-09-22 04:58:26 +00004773 const uint32_t thread_idx_id = thread->GetIndexID();
Jason Molendab57e4a12013-11-04 09:33:30 +00004774 StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
Jim Ingham11b0e052013-02-19 23:22:45 +00004775 if (!selected_frame_sp)
4776 {
4777 thread->SetSelectedFrame(0);
4778 selected_frame_sp = thread->GetSelectedFrame();
4779 if (!selected_frame_sp)
4780 {
4781 errors.Printf("RunThreadPlan called without a selected frame on thread %d", thread_idx_id);
Jim Ingham8646d3c2014-05-05 02:47:44 +00004782 return eExpressionSetupError;
Jim Ingham11b0e052013-02-19 23:22:45 +00004783 }
4784 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004785
Jim Ingham11b0e052013-02-19 23:22:45 +00004786 StackID ctx_frame_id = selected_frame_sp->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00004787
4788 // N.B. Running the target may unset the currently selected thread and frame. We don't want to do that either,
4789 // so we should arrange to reset them as well.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004790
Greg Claytonc14ee322011-09-22 04:58:26 +00004791 lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004792
Jim Ingham66243842011-08-13 00:56:10 +00004793 uint32_t selected_tid;
4794 StackID selected_stack_id;
Greg Clayton762f7132011-09-18 18:59:15 +00004795 if (selected_thread_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00004796 {
4797 selected_tid = selected_thread_sp->GetIndexID();
Jim Ingham66243842011-08-13 00:56:10 +00004798 selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00004799 }
4800 else
4801 {
4802 selected_tid = LLDB_INVALID_THREAD_ID;
4803 }
4804
Jim Ingham372787f2012-04-07 00:00:41 +00004805 lldb::thread_t backup_private_state_thread = LLDB_INVALID_HOST_THREAD;
Jim Ingham076b3042012-04-10 01:21:57 +00004806 lldb::StateType old_state;
4807 lldb::ThreadPlanSP stopper_base_plan_sp;
Jim Ingham372787f2012-04-07 00:00:41 +00004808
Greg Clayton5160ce52013-03-27 23:08:40 +00004809 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham372787f2012-04-07 00:00:41 +00004810 if (Host::GetCurrentThread() == m_private_state_thread)
4811 {
Jim Ingham076b3042012-04-10 01:21:57 +00004812 // Yikes, we are running on the private state thread! So we can't wait for public events on this thread, since
4813 // we are the thread that is generating public events.
Jim Ingham372787f2012-04-07 00:00:41 +00004814 // The simplest thing to do is to spin up a temporary thread to handle private state thread events while
Jim Ingham076b3042012-04-10 01:21:57 +00004815 // we are fielding public events here.
4816 if (log)
Jason Molendad251c9d2012-11-17 01:41:04 +00004817 log->Printf ("Running thread plan on private state thread, spinning up another state thread to handle the events.");
Jim Ingham076b3042012-04-10 01:21:57 +00004818
Jim Ingham372787f2012-04-07 00:00:41 +00004819 backup_private_state_thread = m_private_state_thread;
Jim Ingham076b3042012-04-10 01:21:57 +00004820
4821 // One other bit of business: we want to run just this thread plan and anything it pushes, and then stop,
4822 // returning control here.
4823 // But in the normal course of things, the plan above us on the stack would be given a shot at the stop
4824 // event before deciding to stop, and we don't want that. So we insert a "stopper" base plan on the stack
4825 // before the plan we want to run. Since base plans always stop and return control to the user, that will
4826 // do just what we want.
4827 stopper_base_plan_sp.reset(new ThreadPlanBase (*thread));
4828 thread->QueueThreadPlan (stopper_base_plan_sp, false);
4829 // Have to make sure our public state is stopped, since otherwise the reporting logic below doesn't work correctly.
4830 old_state = m_public_state.GetValue();
4831 m_public_state.SetValueNoLock(eStateStopped);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004832
Jim Ingham076b3042012-04-10 01:21:57 +00004833 // Now spin up the private state thread:
Jim Ingham372787f2012-04-07 00:00:41 +00004834 StartPrivateStateThread(true);
4835 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004836
Jim Ingham372787f2012-04-07 00:00:41 +00004837 thread->QueueThreadPlan(thread_plan_sp, false); // This used to pass "true" does that make sense?
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004838
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004839 if (options.GetDebug())
4840 {
4841 // In this case, we aren't actually going to run, we just want to stop right away.
4842 // Flush this thread so we will refetch the stacks and show the correct backtrace.
4843 // FIXME: To make this prettier we should invent some stop reason for this, but that
4844 // is only cosmetic, and this functionality is only of use to lldb developers who can
4845 // live with not pretty...
4846 thread->Flush();
Jim Ingham8646d3c2014-05-05 02:47:44 +00004847 return eExpressionStoppedForDebug;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004848 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004849
Jim Ingham1e7a9ee2011-01-23 21:14:08 +00004850 Listener listener("lldb.process.listener.run-thread-plan");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004851
Sean Callanana46ec452012-07-11 21:31:24 +00004852 lldb::EventSP event_to_broadcast_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004853
Jim Ingham77787032011-01-20 02:03:18 +00004854 {
Sean Callanana46ec452012-07-11 21:31:24 +00004855 // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get
4856 // restored on exit to the function.
4857 //
4858 // If the event needs to propagate beyond the hijacker (e.g., the process exits during execution), then the event
4859 // is put into event_to_broadcast_sp for rebroadcasting.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004860
Sean Callanana46ec452012-07-11 21:31:24 +00004861 ProcessEventHijacker run_thread_plan_hijacker (*this, &listener);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004862
Jim Inghamf48169b2010-11-30 02:22:11 +00004863 if (log)
Jim Ingham0f16e732011-02-08 05:20:59 +00004864 {
4865 StreamString s;
Sean Callanana46ec452012-07-11 21:31:24 +00004866 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
Daniel Malead01b2952012-11-29 21:49:15 +00004867 log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64 " to run thread plan \"%s\".",
Sean Callanana46ec452012-07-11 21:31:24 +00004868 thread->GetIndexID(),
4869 thread->GetID(),
4870 s.GetData());
4871 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004872
Sean Callanana46ec452012-07-11 21:31:24 +00004873 bool got_event;
4874 lldb::EventSP event_sp;
4875 lldb::StateType stop_state = lldb::eStateInvalid;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004876
Sean Callanana46ec452012-07-11 21:31:24 +00004877 TimeValue* timeout_ptr = NULL;
4878 TimeValue real_timeout;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004879
Jim Ingham0161b492013-02-09 01:29:05 +00004880 bool before_first_timeout = true; // This is set to false the first time that we have to halt the target.
Sean Callanana46ec452012-07-11 21:31:24 +00004881 bool do_resume = true;
Jim Ingham184e9812013-01-15 02:47:48 +00004882 bool handle_running_event = true;
Jim Ingham35e1bda2012-10-16 21:41:58 +00004883 const uint64_t default_one_thread_timeout_usec = 250000;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004884
Jim Ingham0161b492013-02-09 01:29:05 +00004885 // This is just for accounting:
4886 uint32_t num_resumes = 0;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004887
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004888 uint32_t timeout_usec = options.GetTimeoutUsec();
Jim Inghamfd95f892014-04-22 01:41:52 +00004889 uint32_t one_thread_timeout_usec;
4890 uint32_t all_threads_timeout_usec = 0;
Jim Inghamfe1c3422014-04-16 02:24:48 +00004891
4892 // If we are going to run all threads the whole time, or if we are only going to run one thread,
4893 // then we don't need the first timeout. So we set the final timeout, and pretend we are after the
4894 // first timeout already.
4895
4896 if (!options.GetStopOthers() || !options.GetTryAllThreads())
Jim Ingham286fb1e2014-02-28 02:52:06 +00004897 {
4898 before_first_timeout = false;
Jim Inghamfd95f892014-04-22 01:41:52 +00004899 one_thread_timeout_usec = 0;
4900 all_threads_timeout_usec = timeout_usec;
Jim Ingham286fb1e2014-02-28 02:52:06 +00004901 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00004902 else
Jim Ingham0161b492013-02-09 01:29:05 +00004903 {
Jim Inghamfd95f892014-04-22 01:41:52 +00004904 uint32_t option_one_thread_timeout = options.GetOneThreadTimeoutUsec();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004905
Jim Ingham914f4e72014-03-28 21:58:28 +00004906 // If the overall wait is forever, then we only need to set the one thread timeout:
4907 if (timeout_usec == 0)
4908 {
Ed Maste801335c2014-03-31 19:28:14 +00004909 if (option_one_thread_timeout != 0)
Jim Inghamfd95f892014-04-22 01:41:52 +00004910 one_thread_timeout_usec = option_one_thread_timeout;
Jim Ingham914f4e72014-03-28 21:58:28 +00004911 else
Jim Inghamfd95f892014-04-22 01:41:52 +00004912 one_thread_timeout_usec = default_one_thread_timeout_usec;
Jim Ingham914f4e72014-03-28 21:58:28 +00004913 }
Jim Ingham0161b492013-02-09 01:29:05 +00004914 else
4915 {
Jim Ingham914f4e72014-03-28 21:58:28 +00004916 // Otherwise, if the one thread timeout is set, make sure it isn't longer than the overall timeout,
4917 // and use it, otherwise use half the total timeout, bounded by the default_one_thread_timeout_usec.
4918 uint64_t computed_one_thread_timeout;
4919 if (option_one_thread_timeout != 0)
4920 {
4921 if (timeout_usec < option_one_thread_timeout)
4922 {
4923 errors.Printf("RunThreadPlan called without one thread timeout greater than total timeout");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004924 return eExpressionSetupError;
Jim Ingham914f4e72014-03-28 21:58:28 +00004925 }
4926 computed_one_thread_timeout = option_one_thread_timeout;
4927 }
4928 else
4929 {
4930 computed_one_thread_timeout = timeout_usec / 2;
4931 if (computed_one_thread_timeout > default_one_thread_timeout_usec)
4932 computed_one_thread_timeout = default_one_thread_timeout_usec;
4933 }
Jim Inghamfd95f892014-04-22 01:41:52 +00004934 one_thread_timeout_usec = computed_one_thread_timeout;
4935 all_threads_timeout_usec = timeout_usec - one_thread_timeout_usec;
4936
Jim Ingham0161b492013-02-09 01:29:05 +00004937 }
Jim Ingham0161b492013-02-09 01:29:05 +00004938 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00004939
4940 if (log)
Jim Inghamfd95f892014-04-22 01:41:52 +00004941 log->Printf ("Stop others: %u, try all: %u, before_first: %u, one thread: %" PRIu32 " - all threads: %" PRIu32 ".\n",
Jim Inghamfe1c3422014-04-16 02:24:48 +00004942 options.GetStopOthers(),
4943 options.GetTryAllThreads(),
Jim Inghamfd95f892014-04-22 01:41:52 +00004944 before_first_timeout,
4945 one_thread_timeout_usec,
4946 all_threads_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00004947
Jim Ingham1460e4b2014-01-10 23:46:59 +00004948 // This isn't going to work if there are unfetched events on the queue.
4949 // Are there cases where we might want to run the remaining events here, and then try to
4950 // call the function? That's probably being too tricky for our own good.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004951
Jim Ingham1460e4b2014-01-10 23:46:59 +00004952 Event *other_events = listener.PeekAtNextEvent();
4953 if (other_events != NULL)
4954 {
4955 errors.Printf("Calling RunThreadPlan with pending events on the queue.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004956 return eExpressionSetupError;
Jim Ingham1460e4b2014-01-10 23:46:59 +00004957 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004958
Jim Ingham1460e4b2014-01-10 23:46:59 +00004959 // We also need to make sure that the next event is delivered. We might be calling a function as part of
4960 // a thread plan, in which case the last delivered event could be the running event, and we don't want
4961 // event coalescing to cause us to lose OUR running event...
4962 ForceNextEventDelivery();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004963
Jim Ingham8559a352012-11-26 23:52:18 +00004964 // This while loop must exit out the bottom, there's cleanup that we need to do when we are done.
4965 // So don't call return anywhere within it.
Jim Ingham35878c42014-04-08 21:33:21 +00004966
4967#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
4968 // It's pretty much impossible to write test cases for things like:
4969 // One thread timeout expires, I go to halt, but the process already stopped
4970 // on the function call stop breakpoint. Turning on this define will make us not
4971 // fetch the first event till after the halt. So if you run a quick function, it will have
4972 // completed, and the completion event will be waiting, when you interrupt for halt.
4973 // The expression evaluation should still succeed.
4974 bool miss_first_event = true;
4975#endif
Jim Inghamfd95f892014-04-22 01:41:52 +00004976 TimeValue one_thread_timeout;
4977 TimeValue final_timeout;
4978
Jim Ingham35878c42014-04-08 21:33:21 +00004979
Sean Callanana46ec452012-07-11 21:31:24 +00004980 while (1)
4981 {
4982 // We usually want to resume the process if we get to the top of the loop.
4983 // The only exception is if we get two running events with no intervening
4984 // stop, which can happen, we will just wait for then next stop event.
Jim Ingham0161b492013-02-09 01:29:05 +00004985 if (log)
4986 log->Printf ("Top of while loop: do_resume: %i handle_running_event: %i before_first_timeout: %i.",
4987 do_resume,
4988 handle_running_event,
4989 before_first_timeout);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004990
Jim Ingham184e9812013-01-15 02:47:48 +00004991 if (do_resume || handle_running_event)
Sean Callanana46ec452012-07-11 21:31:24 +00004992 {
4993 // Do the initial resume and wait for the running event before going further.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004994
Jim Ingham184e9812013-01-15 02:47:48 +00004995 if (do_resume)
Sean Callanana46ec452012-07-11 21:31:24 +00004996 {
Jim Ingham0161b492013-02-09 01:29:05 +00004997 num_resumes++;
Jim Ingham184e9812013-01-15 02:47:48 +00004998 Error resume_error = PrivateResume ();
4999 if (!resume_error.Success())
5000 {
Jim Ingham0161b492013-02-09 01:29:05 +00005001 errors.Printf("Error resuming inferior the %d time: \"%s\".\n",
5002 num_resumes,
5003 resume_error.AsCString());
Jim Ingham8646d3c2014-05-05 02:47:44 +00005004 return_value = eExpressionSetupError;
Jim Ingham184e9812013-01-15 02:47:48 +00005005 break;
5006 }
Sean Callanana46ec452012-07-11 21:31:24 +00005007 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005008
Jim Ingham0161b492013-02-09 01:29:05 +00005009 TimeValue resume_timeout = TimeValue::Now();
5010 resume_timeout.OffsetWithMicroSeconds(500000);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005011
Jim Ingham0161b492013-02-09 01:29:05 +00005012 got_event = listener.WaitForEvent(&resume_timeout, event_sp);
Sean Callanana46ec452012-07-11 21:31:24 +00005013 if (!got_event)
5014 {
5015 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005016 log->Printf ("Process::RunThreadPlan(): didn't get any event after resume %d, exiting.",
5017 num_resumes);
Sean Callanana46ec452012-07-11 21:31:24 +00005018
Jim Ingham0161b492013-02-09 01:29:05 +00005019 errors.Printf("Didn't get any event after resume %d, exiting.", num_resumes);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005020 return_value = eExpressionSetupError;
Sean Callanana46ec452012-07-11 21:31:24 +00005021 break;
5022 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005023
Sean Callanana46ec452012-07-11 21:31:24 +00005024 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Ingham0161b492013-02-09 01:29:05 +00005025
Sean Callanana46ec452012-07-11 21:31:24 +00005026 if (stop_state != eStateRunning)
5027 {
Jim Ingham0161b492013-02-09 01:29:05 +00005028 bool restarted = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005029
Jim Ingham0161b492013-02-09 01:29:05 +00005030 if (stop_state == eStateStopped)
5031 {
5032 restarted = Process::ProcessEventData::GetRestartedFromEvent(event_sp.get());
5033 if (log)
5034 log->Printf("Process::RunThreadPlan(): didn't get running event after "
5035 "resume %d, got %s instead (restarted: %i, do_resume: %i, handle_running_event: %i).",
5036 num_resumes,
5037 StateAsCString(stop_state),
5038 restarted,
5039 do_resume,
5040 handle_running_event);
5041 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005042
Jim Ingham0161b492013-02-09 01:29:05 +00005043 if (restarted)
5044 {
5045 // This is probably an overabundance of caution, I don't think I should ever get a stopped & restarted
5046 // event here. But if I do, the best thing is to Halt and then get out of here.
5047 Halt();
5048 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005049
Jim Ingham35e1bda2012-10-16 21:41:58 +00005050 errors.Printf("Didn't get running event after initial resume, got %s instead.",
5051 StateAsCString(stop_state));
Jim Ingham8646d3c2014-05-05 02:47:44 +00005052 return_value = eExpressionSetupError;
Sean Callanana46ec452012-07-11 21:31:24 +00005053 break;
5054 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005055
Sean Callanana46ec452012-07-11 21:31:24 +00005056 if (log)
5057 log->PutCString ("Process::RunThreadPlan(): resuming succeeded.");
5058 // We need to call the function synchronously, so spin waiting for it to return.
5059 // If we get interrupted while executing, we're going to lose our context, and
5060 // won't be able to gather the result at this point.
5061 // We set the timeout AFTER the resume, since the resume takes some time and we
5062 // don't want to charge that to the timeout.
Sean Callanana46ec452012-07-11 21:31:24 +00005063 }
Jim Ingham0f16e732011-02-08 05:20:59 +00005064 else
5065 {
Sean Callanana46ec452012-07-11 21:31:24 +00005066 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005067 log->PutCString ("Process::RunThreadPlan(): waiting for next event.");
Jim Ingham0f16e732011-02-08 05:20:59 +00005068 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005069
Jim Ingham0161b492013-02-09 01:29:05 +00005070 if (before_first_timeout)
5071 {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005072 if (options.GetTryAllThreads())
Jim Inghamfd95f892014-04-22 01:41:52 +00005073 {
5074 one_thread_timeout = TimeValue::Now();
5075 one_thread_timeout.OffsetWithMicroSeconds(one_thread_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005076 timeout_ptr = &one_thread_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005077 }
Jim Ingham0161b492013-02-09 01:29:05 +00005078 else
5079 {
5080 if (timeout_usec == 0)
5081 timeout_ptr = NULL;
5082 else
Jim Inghamfd95f892014-04-22 01:41:52 +00005083 {
5084 final_timeout = TimeValue::Now();
5085 final_timeout.OffsetWithMicroSeconds (timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005086 timeout_ptr = &final_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005087 }
Jim Ingham0161b492013-02-09 01:29:05 +00005088 }
5089 }
5090 else
5091 {
5092 if (timeout_usec == 0)
5093 timeout_ptr = NULL;
5094 else
Jim Inghamfd95f892014-04-22 01:41:52 +00005095 {
5096 final_timeout = TimeValue::Now();
5097 final_timeout.OffsetWithMicroSeconds (all_threads_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005098 timeout_ptr = &final_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005099 }
Jim Ingham0161b492013-02-09 01:29:05 +00005100 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005101
Jim Ingham0161b492013-02-09 01:29:05 +00005102 do_resume = true;
5103 handle_running_event = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005104
Sean Callanana46ec452012-07-11 21:31:24 +00005105 // Now wait for the process to stop again:
Sean Callanana46ec452012-07-11 21:31:24 +00005106 event_sp.reset();
Jim Ingham0f16e732011-02-08 05:20:59 +00005107
Jim Ingham0f16e732011-02-08 05:20:59 +00005108 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00005109 {
Sean Callanana46ec452012-07-11 21:31:24 +00005110 if (timeout_ptr)
5111 {
Matt Kopec676a4872013-02-21 23:55:31 +00005112 log->Printf ("Process::RunThreadPlan(): about to wait - now is %" PRIu64 " - endpoint is %" PRIu64,
Jim Ingham0161b492013-02-09 01:29:05 +00005113 TimeValue::Now().GetAsMicroSecondsSinceJan1_1970(),
5114 timeout_ptr->GetAsMicroSecondsSinceJan1_1970());
Sean Callanana46ec452012-07-11 21:31:24 +00005115 }
Jim Ingham20829ac2011-08-09 22:24:33 +00005116 else
Sean Callanana46ec452012-07-11 21:31:24 +00005117 {
5118 log->Printf ("Process::RunThreadPlan(): about to wait forever.");
5119 }
5120 }
Jim Ingham35878c42014-04-08 21:33:21 +00005121
5122#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5123 // See comment above...
5124 if (miss_first_event)
5125 {
5126 usleep(1000);
5127 miss_first_event = false;
5128 got_event = false;
5129 }
5130 else
5131#endif
Sean Callanana46ec452012-07-11 21:31:24 +00005132 got_event = listener.WaitForEvent (timeout_ptr, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005133
Sean Callanana46ec452012-07-11 21:31:24 +00005134 if (got_event)
5135 {
5136 if (event_sp.get())
5137 {
5138 bool keep_going = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005139 if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005140 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005141 Halt();
Jim Ingham8646d3c2014-05-05 02:47:44 +00005142 return_value = eExpressionInterrupted;
Jim Inghamcfc09352012-07-27 23:57:19 +00005143 errors.Printf ("Execution halted by user interrupt.");
5144 if (log)
5145 log->Printf ("Process::RunThreadPlan(): Got interrupted by eBroadcastBitInterrupted, exiting.");
Jim Ingham0161b492013-02-09 01:29:05 +00005146 break;
Jim Inghamcfc09352012-07-27 23:57:19 +00005147 }
5148 else
5149 {
5150 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5151 if (log)
5152 log->Printf("Process::RunThreadPlan(): in while loop, got event: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005153
Jim Inghamcfc09352012-07-27 23:57:19 +00005154 switch (stop_state)
Sean Callanana46ec452012-07-11 21:31:24 +00005155 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005156 case lldb::eStateStopped:
Sean Callanana46ec452012-07-11 21:31:24 +00005157 {
Jim Ingham0161b492013-02-09 01:29:05 +00005158 // We stopped, figure out what we are going to do now.
Jim Inghamcfc09352012-07-27 23:57:19 +00005159 ThreadSP thread_sp = GetThreadList().FindThreadByIndexID (thread_idx_id);
5160 if (!thread_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005161 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005162 // Ooh, our thread has vanished. Unlikely that this was successful execution...
Sean Callanana46ec452012-07-11 21:31:24 +00005163 if (log)
Jim Inghamcfc09352012-07-27 23:57:19 +00005164 log->Printf ("Process::RunThreadPlan(): execution completed but our thread (index-id=%u) has vanished.", thread_idx_id);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005165 return_value = eExpressionInterrupted;
Sean Callanana46ec452012-07-11 21:31:24 +00005166 }
5167 else
5168 {
Jim Ingham0161b492013-02-09 01:29:05 +00005169 // If we were restarted, we just need to go back up to fetch another event.
5170 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
Jim Inghamcfc09352012-07-27 23:57:19 +00005171 {
5172 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005173 {
5174 log->Printf ("Process::RunThreadPlan(): Got a stop and restart, so we'll continue waiting.");
5175 }
5176 keep_going = true;
5177 do_resume = false;
5178 handle_running_event = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005179
Jim Inghamcfc09352012-07-27 23:57:19 +00005180 }
5181 else
5182 {
Jim Ingham0161b492013-02-09 01:29:05 +00005183 StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
5184 StopReason stop_reason = eStopReasonInvalid;
5185 if (stop_info_sp)
5186 stop_reason = stop_info_sp->GetStopReason();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005187
Jim Ingham0161b492013-02-09 01:29:05 +00005188 // FIXME: We only check if the stop reason is plan complete, should we make sure that
5189 // it is OUR plan that is complete?
5190 if (stop_reason == eStopReasonPlanComplete)
Jim Ingham184e9812013-01-15 02:47:48 +00005191 {
5192 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005193 log->PutCString ("Process::RunThreadPlan(): execution completed successfully.");
5194 // Now mark this plan as private so it doesn't get reported as the stop reason
5195 // after this point.
5196 if (thread_plan_sp)
5197 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005198 return_value = eExpressionCompleted;
Jim Ingham184e9812013-01-15 02:47:48 +00005199 }
5200 else
5201 {
Jim Ingham0161b492013-02-09 01:29:05 +00005202 // Something restarted the target, so just wait for it to stop for real.
Jim Ingham184e9812013-01-15 02:47:48 +00005203 if (stop_reason == eStopReasonBreakpoint)
Jim Ingham0161b492013-02-09 01:29:05 +00005204 {
5205 if (log)
5206 log->Printf ("Process::RunThreadPlan() stopped for breakpoint: %s.", stop_info_sp->GetDescription());
Jim Ingham8646d3c2014-05-05 02:47:44 +00005207 return_value = eExpressionHitBreakpoint;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005208 if (!options.DoesIgnoreBreakpoints())
Sean Callanan4b388c92013-07-30 19:54:09 +00005209 {
5210 event_to_broadcast_sp = event_sp;
5211 }
Jim Ingham0161b492013-02-09 01:29:05 +00005212 }
Jim Ingham184e9812013-01-15 02:47:48 +00005213 else
Jim Ingham0161b492013-02-09 01:29:05 +00005214 {
5215 if (log)
5216 log->PutCString ("Process::RunThreadPlan(): thread plan didn't successfully complete.");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005217 if (!options.DoesUnwindOnError())
Sean Callanan4b388c92013-07-30 19:54:09 +00005218 event_to_broadcast_sp = event_sp;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005219 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005220 }
Jim Ingham184e9812013-01-15 02:47:48 +00005221 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005222 }
Sean Callanana46ec452012-07-11 21:31:24 +00005223 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005224 }
5225 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005226
Jim Inghamcfc09352012-07-27 23:57:19 +00005227 case lldb::eStateRunning:
Jim Ingham0161b492013-02-09 01:29:05 +00005228 // This shouldn't really happen, but sometimes we do get two running events without an
5229 // intervening stop, and in that case we should just go back to waiting for the stop.
Jim Inghamcfc09352012-07-27 23:57:19 +00005230 do_resume = false;
5231 keep_going = true;
Jim Ingham184e9812013-01-15 02:47:48 +00005232 handle_running_event = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005233 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005234
Jim Inghamcfc09352012-07-27 23:57:19 +00005235 default:
5236 if (log)
5237 log->Printf("Process::RunThreadPlan(): execution stopped with unexpected state: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005238
Jim Inghamcfc09352012-07-27 23:57:19 +00005239 if (stop_state == eStateExited)
5240 event_to_broadcast_sp = event_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005241
Sean Callananbf154da2012-08-08 17:35:10 +00005242 errors.Printf ("Execution stopped with unexpected state.\n");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005243 return_value = eExpressionInterrupted;
Jim Inghamcfc09352012-07-27 23:57:19 +00005244 break;
5245 }
Sean Callanana46ec452012-07-11 21:31:24 +00005246 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005247
Sean Callanana46ec452012-07-11 21:31:24 +00005248 if (keep_going)
5249 continue;
5250 else
5251 break;
5252 }
5253 else
5254 {
5255 if (log)
5256 log->PutCString ("Process::RunThreadPlan(): got_event was true, but the event pointer was null. How odd...");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005257 return_value = eExpressionInterrupted;
Sean Callanana46ec452012-07-11 21:31:24 +00005258 break;
5259 }
5260 }
5261 else
5262 {
5263 // If we didn't get an event that means we've timed out...
5264 // We will interrupt the process here. Depending on what we were asked to do we will
5265 // either exit, or try with all threads running for the same timeout.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005266
Sean Callanana46ec452012-07-11 21:31:24 +00005267 if (log) {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005268 if (options.GetTryAllThreads())
Sean Callanana46ec452012-07-11 21:31:24 +00005269 {
Jim Ingham0161b492013-02-09 01:29:05 +00005270 if (before_first_timeout)
Jim Inghamfe1c3422014-04-16 02:24:48 +00005271 {
5272 if (timeout_usec != 0)
5273 {
Jim Inghamfe1c3422014-04-16 02:24:48 +00005274 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
Jim Inghamfd95f892014-04-22 01:41:52 +00005275 "running for %" PRIu32 " usec with all threads enabled.",
5276 all_threads_timeout_usec);
Jim Inghamfe1c3422014-04-16 02:24:48 +00005277 }
5278 else
5279 {
5280 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
Ed Mastee61c7b02014-04-29 17:48:06 +00005281 "running forever with all threads enabled.");
Jim Inghamfe1c3422014-04-16 02:24:48 +00005282 }
5283 }
Sean Callanana46ec452012-07-11 21:31:24 +00005284 else
5285 log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled "
Jason Molenda6a8658a2013-10-27 02:32:23 +00005286 "and timeout: %u timed out, abandoning execution.",
Jim Ingham35e1bda2012-10-16 21:41:58 +00005287 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005288 }
5289 else
Jason Molenda6a8658a2013-10-27 02:32:23 +00005290 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %u timed out, "
Jim Ingham35e1bda2012-10-16 21:41:58 +00005291 "abandoning execution.",
5292 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005293 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005294
Jim Ingham0161b492013-02-09 01:29:05 +00005295 // It is possible that between the time we issued the Halt, and we get around to calling Halt the target
5296 // could have stopped. That's fine, Halt will figure that out and send the appropriate Stopped event.
5297 // BUT it is also possible that we stopped & restarted (e.g. hit a signal with "stop" set to false.) In
5298 // that case, we'll get the stopped & restarted event, and we should go back to waiting for the Halt's
5299 // stopped event. That's what this while loop does.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005300
Jim Ingham0161b492013-02-09 01:29:05 +00005301 bool back_to_top = true;
5302 uint32_t try_halt_again = 0;
5303 bool do_halt = true;
5304 const uint32_t num_retries = 5;
5305 while (try_halt_again < num_retries)
Sean Callanana46ec452012-07-11 21:31:24 +00005306 {
Jim Ingham0161b492013-02-09 01:29:05 +00005307 Error halt_error;
5308 if (do_halt)
5309 {
5310 if (log)
5311 log->Printf ("Process::RunThreadPlan(): Running Halt.");
5312 halt_error = Halt();
5313 }
5314 if (halt_error.Success())
5315 {
5316 if (log)
5317 log->PutCString ("Process::RunThreadPlan(): Halt succeeded.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005318
Jim Ingham0161b492013-02-09 01:29:05 +00005319 real_timeout = TimeValue::Now();
5320 real_timeout.OffsetWithMicroSeconds(500000);
5321
5322 got_event = listener.WaitForEvent(&real_timeout, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005323
Jim Ingham0161b492013-02-09 01:29:05 +00005324 if (got_event)
Sean Callanana46ec452012-07-11 21:31:24 +00005325 {
Jim Ingham0161b492013-02-09 01:29:05 +00005326 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5327 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00005328 {
Jim Ingham0161b492013-02-09 01:29:05 +00005329 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state));
5330 if (stop_state == lldb::eStateStopped
5331 && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
5332 log->PutCString (" Event was the Halt interruption event.");
Sean Callanana46ec452012-07-11 21:31:24 +00005333 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005334
Jim Ingham0161b492013-02-09 01:29:05 +00005335 if (stop_state == lldb::eStateStopped)
Sean Callanana46ec452012-07-11 21:31:24 +00005336 {
Jim Ingham0161b492013-02-09 01:29:05 +00005337 // Between the time we initiated the Halt and the time we delivered it, the process could have
5338 // already finished its job. Check that here:
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005339
Jim Ingham0161b492013-02-09 01:29:05 +00005340 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
5341 {
5342 if (log)
5343 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
5344 "Exiting wait loop.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005345 return_value = eExpressionCompleted;
Jim Ingham0161b492013-02-09 01:29:05 +00005346 back_to_top = false;
5347 break;
5348 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005349
Jim Ingham0161b492013-02-09 01:29:05 +00005350 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
5351 {
5352 if (log)
5353 log->PutCString ("Process::RunThreadPlan(): Went to halt but got a restarted event, there must be an un-restarted stopped event so try again... "
5354 "Exiting wait loop.");
5355 try_halt_again++;
5356 do_halt = false;
5357 continue;
5358 }
Sean Callanana46ec452012-07-11 21:31:24 +00005359
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005360 if (!options.GetTryAllThreads())
Jim Ingham0161b492013-02-09 01:29:05 +00005361 {
5362 if (log)
5363 log->PutCString ("Process::RunThreadPlan(): try_all_threads was false, we stopped so now we're quitting.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005364 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005365 back_to_top = false;
5366 break;
5367 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005368
Jim Ingham0161b492013-02-09 01:29:05 +00005369 if (before_first_timeout)
5370 {
5371 // Set all the other threads to run, and return to the top of the loop, which will continue;
5372 before_first_timeout = false;
5373 thread_plan_sp->SetStopOthers (false);
5374 if (log)
5375 log->PutCString ("Process::RunThreadPlan(): about to resume.");
Sean Callanana46ec452012-07-11 21:31:24 +00005376
Jim Ingham0161b492013-02-09 01:29:05 +00005377 back_to_top = true;
5378 break;
5379 }
5380 else
5381 {
5382 // Running all threads failed, so return Interrupted.
5383 if (log)
5384 log->PutCString("Process::RunThreadPlan(): running all threads timed out.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005385 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005386 back_to_top = false;
5387 break;
5388 }
Sean Callanana46ec452012-07-11 21:31:24 +00005389 }
5390 }
5391 else
Jim Ingham0161b492013-02-09 01:29:05 +00005392 { if (log)
5393 log->PutCString("Process::RunThreadPlan(): halt said it succeeded, but I got no event. "
5394 "I'm getting out of here passing Interrupted.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005395 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005396 back_to_top = false;
5397 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005398 }
5399 }
Jim Ingham0161b492013-02-09 01:29:05 +00005400 else
5401 {
5402 try_halt_again++;
5403 continue;
5404 }
Sean Callanana46ec452012-07-11 21:31:24 +00005405 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005406
Jim Ingham0161b492013-02-09 01:29:05 +00005407 if (!back_to_top || try_halt_again > num_retries)
5408 break;
5409 else
5410 continue;
Sean Callanana46ec452012-07-11 21:31:24 +00005411 }
Sean Callanana46ec452012-07-11 21:31:24 +00005412 } // END WAIT LOOP
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005413
Sean Callanana46ec452012-07-11 21:31:24 +00005414 // If we had to start up a temporary private state thread to run this thread plan, shut it down now.
5415 if (IS_VALID_LLDB_HOST_THREAD(backup_private_state_thread))
5416 {
5417 StopPrivateStateThread();
5418 Error error;
5419 m_private_state_thread = backup_private_state_thread;
Sean Callanan9a028512012-08-09 00:50:26 +00005420 if (stopper_base_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005421 {
5422 thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
5423 }
5424 m_public_state.SetValueNoLock(old_state);
5425
5426 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005427
Jim Ingham184e9812013-01-15 02:47:48 +00005428 // Restore the thread state if we are going to discard the plan execution. There are three cases where this
5429 // could happen:
5430 // 1) The execution successfully completed
5431 // 2) We hit a breakpoint, and ignore_breakpoints was true
5432 // 3) We got some other error, and discard_on_error was true
Jim Ingham8646d3c2014-05-05 02:47:44 +00005433 bool should_unwind = (return_value == eExpressionInterrupted && options.DoesUnwindOnError())
5434 || (return_value == eExpressionHitBreakpoint && options.DoesIgnoreBreakpoints());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005435
Jim Ingham8646d3c2014-05-05 02:47:44 +00005436 if (return_value == eExpressionCompleted
Jim Ingham184e9812013-01-15 02:47:48 +00005437 || should_unwind)
Jim Ingham8559a352012-11-26 23:52:18 +00005438 {
5439 thread_plan_sp->RestoreThreadState();
5440 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005441
Sean Callanana46ec452012-07-11 21:31:24 +00005442 // Now do some processing on the results of the run:
Jim Ingham8646d3c2014-05-05 02:47:44 +00005443 if (return_value == eExpressionInterrupted || return_value == eExpressionHitBreakpoint)
Sean Callanana46ec452012-07-11 21:31:24 +00005444 {
5445 if (log)
5446 {
5447 StreamString s;
5448 if (event_sp)
5449 event_sp->Dump (&s);
5450 else
5451 {
5452 log->PutCString ("Process::RunThreadPlan(): Stop event that interrupted us is NULL.");
5453 }
5454
5455 StreamString ts;
5456
5457 const char *event_explanation = NULL;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005458
Sean Callanana46ec452012-07-11 21:31:24 +00005459 do
5460 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005461 if (!event_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005462 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005463 event_explanation = "<no event>";
Sean Callanana46ec452012-07-11 21:31:24 +00005464 break;
5465 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005466 else if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005467 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005468 event_explanation = "<user interrupt>";
Sean Callanana46ec452012-07-11 21:31:24 +00005469 break;
5470 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005471 else
Sean Callanana46ec452012-07-11 21:31:24 +00005472 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005473 const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get());
5474
5475 if (!event_data)
Sean Callanana46ec452012-07-11 21:31:24 +00005476 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005477 event_explanation = "<no event data>";
5478 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005479 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005480
Jim Inghamcfc09352012-07-27 23:57:19 +00005481 Process *process = event_data->GetProcessSP().get();
5482
5483 if (!process)
Sean Callanana46ec452012-07-11 21:31:24 +00005484 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005485 event_explanation = "<no process>";
5486 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005487 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005488
Jim Inghamcfc09352012-07-27 23:57:19 +00005489 ThreadList &thread_list = process->GetThreadList();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005490
Jim Inghamcfc09352012-07-27 23:57:19 +00005491 uint32_t num_threads = thread_list.GetSize();
5492 uint32_t thread_index;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005493
Jim Inghamcfc09352012-07-27 23:57:19 +00005494 ts.Printf("<%u threads> ", num_threads);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005495
Jim Inghamcfc09352012-07-27 23:57:19 +00005496 for (thread_index = 0;
5497 thread_index < num_threads;
5498 ++thread_index)
5499 {
5500 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005501
Jim Inghamcfc09352012-07-27 23:57:19 +00005502 if (!thread)
5503 {
5504 ts.Printf("<?> ");
5505 continue;
5506 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005507
Daniel Malead01b2952012-11-29 21:49:15 +00005508 ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00005509 RegisterContext *register_context = thread->GetRegisterContext().get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005510
Jim Inghamcfc09352012-07-27 23:57:19 +00005511 if (register_context)
Daniel Malead01b2952012-11-29 21:49:15 +00005512 ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
Jim Inghamcfc09352012-07-27 23:57:19 +00005513 else
5514 ts.Printf("[ip unknown] ");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005515
Jim Inghamcfc09352012-07-27 23:57:19 +00005516 lldb::StopInfoSP stop_info_sp = thread->GetStopInfo();
5517 if (stop_info_sp)
5518 {
5519 const char *stop_desc = stop_info_sp->GetDescription();
5520 if (stop_desc)
5521 ts.PutCString (stop_desc);
5522 }
5523 ts.Printf(">");
5524 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005525
Jim Inghamcfc09352012-07-27 23:57:19 +00005526 event_explanation = ts.GetData();
Sean Callanana46ec452012-07-11 21:31:24 +00005527 }
Sean Callanana46ec452012-07-11 21:31:24 +00005528 } while (0);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005529
Jim Inghamcfc09352012-07-27 23:57:19 +00005530 if (event_explanation)
5531 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation);
Sean Callanana46ec452012-07-11 21:31:24 +00005532 else
Jim Inghamcfc09352012-07-27 23:57:19 +00005533 log->Printf("Process::RunThreadPlan(): execution interrupted: %s", s.GetData());
5534 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005535
Jim Inghame4483cf2013-09-27 01:13:01 +00005536 if (should_unwind)
Jim Inghamcfc09352012-07-27 23:57:19 +00005537 {
5538 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005539 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - discarding thread plans up to %p.",
5540 static_cast<void*>(thread_plan_sp.get()));
Jim Inghamcfc09352012-07-27 23:57:19 +00005541 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
5542 thread_plan_sp->SetPrivate (orig_plan_private);
5543 }
5544 else
5545 {
5546 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005547 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - for plan: %p not discarding.",
5548 static_cast<void*>(thread_plan_sp.get()));
Sean Callanana46ec452012-07-11 21:31:24 +00005549 }
5550 }
Jim Ingham8646d3c2014-05-05 02:47:44 +00005551 else if (return_value == eExpressionSetupError)
Sean Callanana46ec452012-07-11 21:31:24 +00005552 {
5553 if (log)
5554 log->PutCString("Process::RunThreadPlan(): execution set up error.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005555
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005556 if (options.DoesUnwindOnError())
Jim Ingham0f16e732011-02-08 05:20:59 +00005557 {
Greg Claytonc14ee322011-09-22 04:58:26 +00005558 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Ingham4b536182011-08-09 02:12:22 +00005559 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Ingham0f16e732011-02-08 05:20:59 +00005560 }
Jim Inghamf48169b2010-11-30 02:22:11 +00005561 }
5562 else
5563 {
Sean Callanana46ec452012-07-11 21:31:24 +00005564 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
Jim Inghamf48169b2010-11-30 02:22:11 +00005565 {
Jim Ingham0f16e732011-02-08 05:20:59 +00005566 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00005567 log->PutCString("Process::RunThreadPlan(): thread plan is done");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005568 return_value = eExpressionCompleted;
Sean Callanana46ec452012-07-11 21:31:24 +00005569 }
5570 else if (thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
5571 {
5572 if (log)
5573 log->PutCString("Process::RunThreadPlan(): thread plan was discarded");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005574 return_value = eExpressionDiscarded;
Sean Callanana46ec452012-07-11 21:31:24 +00005575 }
5576 else
5577 {
5578 if (log)
5579 log->PutCString("Process::RunThreadPlan(): thread plan stopped in mid course");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005580 if (options.DoesUnwindOnError() && thread_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005581 {
5582 if (log)
Jim Ingham184e9812013-01-15 02:47:48 +00005583 log->PutCString("Process::RunThreadPlan(): discarding thread plan 'cause unwind_on_error is set.");
Sean Callanana46ec452012-07-11 21:31:24 +00005584 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
5585 thread_plan_sp->SetPrivate (orig_plan_private);
5586 }
5587 }
5588 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005589
Sean Callanana46ec452012-07-11 21:31:24 +00005590 // Thread we ran the function in may have gone away because we ran the target
5591 // Check that it's still there, and if it is put it back in the context. Also restore the
5592 // frame in the context if it is still present.
5593 thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
5594 if (thread)
5595 {
5596 exe_ctx.SetFrameSP (thread->GetFrameWithStackID (ctx_frame_id));
5597 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005598
Sean Callanana46ec452012-07-11 21:31:24 +00005599 // Also restore the current process'es selected frame & thread, since this function calling may
5600 // be done behind the user's back.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005601
Sean Callanana46ec452012-07-11 21:31:24 +00005602 if (selected_tid != LLDB_INVALID_THREAD_ID)
5603 {
5604 if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid())
5605 {
5606 // We were able to restore the selected thread, now restore the frame:
Daniel Maleaa012d3a2013-07-31 20:21:20 +00005607 Mutex::Locker lock(GetThreadList().GetMutex());
Jason Molendab57e4a12013-11-04 09:33:30 +00005608 StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
Sean Callanana46ec452012-07-11 21:31:24 +00005609 if (old_frame_sp)
5610 GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
Jim Inghamf48169b2010-11-30 02:22:11 +00005611 }
Jim Inghamf48169b2010-11-30 02:22:11 +00005612 }
5613 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005614
Sean Callanana46ec452012-07-11 21:31:24 +00005615 // If the process exited during the run of the thread plan, notify everyone.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005616
Sean Callanana46ec452012-07-11 21:31:24 +00005617 if (event_to_broadcast_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00005618 {
Sean Callanana46ec452012-07-11 21:31:24 +00005619 if (log)
5620 log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
5621 BroadcastEvent(event_to_broadcast_sp);
Jim Inghamf48169b2010-11-30 02:22:11 +00005622 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005623
Jim Inghamf48169b2010-11-30 02:22:11 +00005624 return return_value;
5625}
5626
5627const char *
Jim Ingham1624a2d2014-05-05 02:26:40 +00005628Process::ExecutionResultAsCString (ExpressionResults result)
Jim Inghamf48169b2010-11-30 02:22:11 +00005629{
5630 const char *result_name;
5631
5632 switch (result)
5633 {
Jim Ingham8646d3c2014-05-05 02:47:44 +00005634 case eExpressionCompleted:
5635 result_name = "eExpressionCompleted";
Jim Inghamf48169b2010-11-30 02:22:11 +00005636 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005637 case eExpressionDiscarded:
5638 result_name = "eExpressionDiscarded";
Jim Inghamf48169b2010-11-30 02:22:11 +00005639 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005640 case eExpressionInterrupted:
5641 result_name = "eExpressionInterrupted";
Jim Inghamf48169b2010-11-30 02:22:11 +00005642 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005643 case eExpressionHitBreakpoint:
5644 result_name = "eExpressionHitBreakpoint";
Jim Ingham184e9812013-01-15 02:47:48 +00005645 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005646 case eExpressionSetupError:
5647 result_name = "eExpressionSetupError";
Jim Inghamf48169b2010-11-30 02:22:11 +00005648 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005649 case eExpressionParseError:
5650 result_name = "eExpressionParseError";
Jim Ingham1624a2d2014-05-05 02:26:40 +00005651 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005652 case eExpressionResultUnavailable:
5653 result_name = "eExpressionResultUnavailable";
Jim Ingham1624a2d2014-05-05 02:26:40 +00005654 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005655 case eExpressionTimedOut:
5656 result_name = "eExpressionTimedOut";
Jim Inghamf48169b2010-11-30 02:22:11 +00005657 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005658 case eExpressionStoppedForDebug:
5659 result_name = "eExpressionStoppedForDebug";
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005660 break;
Jim Inghamf48169b2010-11-30 02:22:11 +00005661 }
5662 return result_name;
5663}
5664
Greg Clayton7260f622011-04-18 08:33:37 +00005665void
5666Process::GetStatus (Stream &strm)
5667{
5668 const StateType state = GetState();
Greg Clayton2637f822011-11-17 01:23:07 +00005669 if (StateIsStoppedState(state, false))
Greg Clayton7260f622011-04-18 08:33:37 +00005670 {
5671 if (state == eStateExited)
5672 {
5673 int exit_status = GetExitStatus();
5674 const char *exit_description = GetExitDescription();
Daniel Malead01b2952012-11-29 21:49:15 +00005675 strm.Printf ("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
Greg Clayton7260f622011-04-18 08:33:37 +00005676 GetID(),
5677 exit_status,
5678 exit_status,
5679 exit_description ? exit_description : "");
5680 }
5681 else
5682 {
5683 if (state == eStateConnected)
5684 strm.Printf ("Connected to remote target.\n");
5685 else
Daniel Malead01b2952012-11-29 21:49:15 +00005686 strm.Printf ("Process %" PRIu64 " %s\n", GetID(), StateAsCString (state));
Greg Clayton7260f622011-04-18 08:33:37 +00005687 }
5688 }
5689 else
5690 {
Daniel Malead01b2952012-11-29 21:49:15 +00005691 strm.Printf ("Process %" PRIu64 " is running.\n", GetID());
Greg Clayton7260f622011-04-18 08:33:37 +00005692 }
5693}
5694
5695size_t
5696Process::GetThreadStatus (Stream &strm,
5697 bool only_threads_with_stop_reason,
5698 uint32_t start_frame,
5699 uint32_t num_frames,
5700 uint32_t num_frames_with_source)
5701{
5702 size_t num_thread_infos_dumped = 0;
5703
Jim Ingham4a65fb12014-03-07 11:20:03 +00005704 // You can't hold the thread list lock while calling Thread::GetStatus. That very well might run code (e.g. if we need it
5705 // to get return values or arguments.) For that to work the process has to be able to acquire it. So instead copy the thread
5706 // ID's, and look them up one by one:
5707
5708 uint32_t num_threads;
5709 std::vector<uint32_t> thread_index_array;
5710 //Scope for thread list locker;
5711 {
5712 Mutex::Locker locker (GetThreadList().GetMutex());
5713 ThreadList &curr_thread_list = GetThreadList();
5714 num_threads = curr_thread_list.GetSize();
5715 uint32_t idx;
5716 thread_index_array.resize(num_threads);
5717 for (idx = 0; idx < num_threads; ++idx)
5718 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetID();
5719 }
5720
Greg Clayton7260f622011-04-18 08:33:37 +00005721 for (uint32_t i = 0; i < num_threads; i++)
5722 {
Jim Ingham4a65fb12014-03-07 11:20:03 +00005723 ThreadSP thread_sp(GetThreadList().FindThreadByID(thread_index_array[i]));
5724 if (thread_sp)
Greg Clayton7260f622011-04-18 08:33:37 +00005725 {
5726 if (only_threads_with_stop_reason)
5727 {
Jim Ingham4a65fb12014-03-07 11:20:03 +00005728 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
Jim Ingham5d88a062012-10-16 00:09:33 +00005729 if (stop_info_sp.get() == NULL || !stop_info_sp->IsValid())
Greg Clayton7260f622011-04-18 08:33:37 +00005730 continue;
5731 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00005732 thread_sp->GetStatus (strm,
Greg Clayton7260f622011-04-18 08:33:37 +00005733 start_frame,
5734 num_frames,
5735 num_frames_with_source);
5736 ++num_thread_infos_dumped;
5737 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00005738 else
5739 {
5740 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
5741 if (log)
5742 log->Printf("Process::GetThreadStatus - thread 0x" PRIu64 " vanished while running Thread::GetStatus.");
5743
5744 }
Greg Clayton7260f622011-04-18 08:33:37 +00005745 }
5746 return num_thread_infos_dumped;
5747}
5748
Greg Claytona9f40ad2012-02-22 04:37:26 +00005749void
5750Process::AddInvalidMemoryRegion (const LoadRange &region)
5751{
5752 m_memory_cache.AddInvalidRange(region.GetRangeBase(), region.GetByteSize());
5753}
5754
5755bool
5756Process::RemoveInvalidMemoryRange (const LoadRange &region)
5757{
5758 return m_memory_cache.RemoveInvalidRange(region.GetRangeBase(), region.GetByteSize());
5759}
5760
Jim Ingham372787f2012-04-07 00:00:41 +00005761void
5762Process::AddPreResumeAction (PreResumeActionCallback callback, void *baton)
5763{
5764 m_pre_resume_actions.push_back(PreResumeCallbackAndBaton (callback, baton));
5765}
5766
5767bool
5768Process::RunPreResumeActions ()
5769{
5770 bool result = true;
5771 while (!m_pre_resume_actions.empty())
5772 {
5773 struct PreResumeCallbackAndBaton action = m_pre_resume_actions.back();
5774 m_pre_resume_actions.pop_back();
5775 bool this_result = action.callback (action.baton);
5776 if (result == true) result = this_result;
5777 }
5778 return result;
5779}
5780
5781void
5782Process::ClearPreResumeActions ()
5783{
5784 m_pre_resume_actions.clear();
5785}
Greg Claytona9f40ad2012-02-22 04:37:26 +00005786
Greg Claytonfa559e52012-05-18 02:38:05 +00005787void
5788Process::Flush ()
5789{
5790 m_thread_list.Flush();
Jason Molenda5e8dce42013-12-13 00:29:16 +00005791 m_extended_thread_list.Flush();
5792 m_extended_thread_stop_id = 0;
5793 m_queue_list.Clear();
5794 m_queue_list_stop_id = 0;
Greg Claytonfa559e52012-05-18 02:38:05 +00005795}
Greg Clayton90ba8112012-12-05 00:16:59 +00005796
5797void
5798Process::DidExec ()
5799{
5800 Target &target = GetTarget();
5801 target.CleanupProcess ();
Greg Claytonb35db632013-11-09 00:03:31 +00005802 target.ClearModules(false);
Greg Clayton90ba8112012-12-05 00:16:59 +00005803 m_dynamic_checkers_ap.reset();
5804 m_abi_sp.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00005805 m_system_runtime_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00005806 m_os_ap.reset();
Greg Clayton15fc2be2013-05-21 01:00:52 +00005807 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00005808 m_jit_loaders_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00005809 m_image_tokens.clear();
5810 m_allocated_memory_cache.Clear();
5811 m_language_runtimes.clear();
Greg Clayton15fc2be2013-05-21 01:00:52 +00005812 m_thread_list.DiscardThreadPlans();
Greg Clayton15fc2be2013-05-21 01:00:52 +00005813 m_memory_cache.Clear(true);
Greg Clayton90ba8112012-12-05 00:16:59 +00005814 DoDidExec();
5815 CompleteAttach ();
Greg Clayton095eeaa2013-11-05 23:28:00 +00005816 // Flush the process (threads and all stack frames) after running CompleteAttach()
5817 // in case the dynamic loader loaded things in new locations.
5818 Flush();
Greg Claytonb35db632013-11-09 00:03:31 +00005819
5820 // After we figure out what was loaded/unloaded in CompleteAttach,
5821 // we need to let the target know so it can do any cleanup it needs to.
5822 target.DidExec();
Greg Clayton90ba8112012-12-05 00:16:59 +00005823}
Greg Clayton095eeaa2013-11-05 23:28:00 +00005824
Jim Ingham1460e4b2014-01-10 23:46:59 +00005825addr_t
5826Process::ResolveIndirectFunction(const Address *address, Error &error)
5827{
5828 if (address == nullptr)
5829 {
Jean-Daniel Dupasef37711f2014-02-08 20:22:05 +00005830 error.SetErrorString("Invalid address argument");
Jim Ingham1460e4b2014-01-10 23:46:59 +00005831 return LLDB_INVALID_ADDRESS;
5832 }
5833
5834 addr_t function_addr = LLDB_INVALID_ADDRESS;
5835
5836 addr_t addr = address->GetLoadAddress(&GetTarget());
5837 std::map<addr_t,addr_t>::const_iterator iter = m_resolved_indirect_addresses.find(addr);
5838 if (iter != m_resolved_indirect_addresses.end())
5839 {
5840 function_addr = (*iter).second;
5841 }
5842 else
5843 {
5844 if (!InferiorCall(this, address, function_addr))
5845 {
5846 Symbol *symbol = address->CalculateSymbolContextSymbol();
5847 error.SetErrorStringWithFormat ("Unable to call resolver for indirect function %s",
5848 symbol ? symbol->GetName().AsCString() : "<UNKNOWN>");
5849 function_addr = LLDB_INVALID_ADDRESS;
5850 }
5851 else
5852 {
5853 m_resolved_indirect_addresses.insert(std::pair<addr_t, addr_t>(addr, function_addr));
5854 }
5855 }
5856 return function_addr;
5857}
5858
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00005859void
5860Process::ModulesDidLoad (ModuleList &module_list)
5861{
5862 SystemRuntime *sys_runtime = GetSystemRuntime();
5863 if (sys_runtime)
5864 {
5865 sys_runtime->ModulesDidLoad (module_list);
5866 }
5867
5868 GetJITLoaders().ModulesDidLoad (module_list);
5869}