blob: d6f1eaadbef9afb5836acab74dc2d2041406568a [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{
Virgile Belloe2607b52013-09-05 16:42:23 +0000489{ LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument, 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, 0, eArgTypeNone, "Disable address space layout randomization when launching a process."},
491{ LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
492{ LLDB_OPT_SET_ALL, false, "working-dir", 'w', OptionParser::eRequiredArgument, 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, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous."},
494{ LLDB_OPT_SET_ALL, false, "environment", 'v', OptionParser::eRequiredArgument, 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, 0, eArgTypeFilename, "Run the process in a shell (not supported on all platforms)."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000496
Virgile Belloe2607b52013-09-05 16:42:23 +0000497{ LLDB_OPT_SET_1 , false, "stdin", 'i', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFilename, "Redirect stdin for the process to <filename>."},
498{ LLDB_OPT_SET_1 , false, "stdout", 'o', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFilename, "Redirect stdout for the process to <filename>."},
499{ LLDB_OPT_SET_1 , false, "stderr", 'e', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFilename, "Redirect stderr for the process to <filename>."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000500
Virgile Belloe2607b52013-09-05 16:42:23 +0000501{ LLDB_OPT_SET_2 , false, "tty", 't', OptionParser::eNoArgument, NULL, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000502
Virgile Belloe2607b52013-09-05 16:42:23 +0000503{ LLDB_OPT_SET_3 , false, "no-stdio", 'n', OptionParser::eNoArgument, NULL, 0, eArgTypeNone, "Do not set up for terminal I/O to go to running process."},
Greg Clayton8b82f082011-04-12 05:54:46 +0000504
505{ 0 , false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
506};
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 Clayton5160ce52013-03-27 23:08:40 +00001416 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001417 bool state_changed = false;
1418
1419 if (log)
1420 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
1421
Andrew Kaylor29d65742013-05-10 17:19:04 +00001422 Mutex::Locker thread_locker(m_thread_list.GetMutex());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001423 Mutex::Locker locker(m_private_state.GetMutex());
1424
1425 const StateType old_state = m_private_state.GetValueNoLock ();
1426 state_changed = old_state != new_state;
Ed Mastec29693f2013-07-02 16:35:47 +00001427
Greg Claytonaa49c832013-05-03 22:25:56 +00001428 const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1429 const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1430 if (old_state_is_stopped != new_state_is_stopped)
1431 {
1432 if (new_state_is_stopped)
Ed Maste64fad602013-07-29 20:58:06 +00001433 m_private_run_lock.SetStopped();
Greg Claytonaa49c832013-05-03 22:25:56 +00001434 else
Ed Maste64fad602013-07-29 20:58:06 +00001435 m_private_run_lock.SetRunning();
Greg Claytonaa49c832013-05-03 22:25:56 +00001436 }
Andrew Kaylor93132f52013-05-28 23:04:25 +00001437
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001438 if (state_changed)
1439 {
1440 m_private_state.SetValueNoLock (new_state);
Greg Clayton2637f822011-11-17 01:23:07 +00001441 if (StateIsStoppedState(new_state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001442 {
Andrew Kaylor29d65742013-05-10 17:19:04 +00001443 // Note, this currently assumes that all threads in the list
1444 // stop when the process stops. In the future we will want to
1445 // support a debugging model where some threads continue to run
1446 // while others are stopped. When that happens we will either need
1447 // a way for the thread list to identify which threads are stopping
1448 // or create a special thread list containing only threads which
1449 // actually stopped.
1450 //
1451 // The process plugin is responsible for managing the actual
1452 // behavior of the threads and should have stopped any threads
1453 // that are going to stop before we get here.
1454 m_thread_list.DidStop();
1455
Jim Ingham4b536182011-08-09 02:12:22 +00001456 m_mod_id.BumpStopID();
Greg Clayton58be07b2011-01-07 06:08:19 +00001457 m_memory_cache.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001458 if (log)
Jim Ingham4b536182011-08-09 02:12:22 +00001459 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_mod_id.GetStopID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001460 }
1461 // Use our target to get a shared pointer to ourselves...
Greg Clayton35a4cc52012-10-29 20:52:08 +00001462 if (m_finalize_called && PrivateStateThreadIsValid() == false)
1463 BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state));
1464 else
1465 m_private_state_broadcaster.BroadcastEvent (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001466 }
1467 else
1468 {
1469 if (log)
Jason Molendafd54b362011-09-20 21:44:10 +00001470 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001471 }
1472}
1473
Jim Ingham0faa43f2011-11-08 03:00:11 +00001474void
1475Process::SetRunningUserExpression (bool on)
1476{
1477 m_mod_id.SetRunningUserExpression (on);
1478}
1479
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001480addr_t
1481Process::GetImageInfoAddress()
1482{
1483 return LLDB_INVALID_ADDRESS;
1484}
1485
Greg Clayton8f343b02010-11-04 01:54:29 +00001486//----------------------------------------------------------------------
1487// LoadImage
1488//
1489// This function provides a default implementation that works for most
1490// unix variants. Any Process subclasses that need to do shared library
1491// loading differently should override LoadImage and UnloadImage and
1492// do what is needed.
1493//----------------------------------------------------------------------
1494uint32_t
1495Process::LoadImage (const FileSpec &image_spec, Error &error)
1496{
Greg Claytonac7a3db2012-04-18 00:05:19 +00001497 char path[PATH_MAX];
1498 image_spec.GetPath(path, sizeof(path));
1499
Greg Clayton8f343b02010-11-04 01:54:29 +00001500 DynamicLoader *loader = GetDynamicLoader();
1501 if (loader)
1502 {
1503 error = loader->CanLoadImage();
1504 if (error.Fail())
1505 return LLDB_INVALID_IMAGE_TOKEN;
1506 }
1507
1508 if (error.Success())
1509 {
1510 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001511
1512 if (thread_sp)
1513 {
Jason Molendab57e4a12013-11-04 09:33:30 +00001514 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
Greg Clayton8f343b02010-11-04 01:54:29 +00001515
1516 if (frame_sp)
1517 {
1518 ExecutionContext exe_ctx;
1519 frame_sp->CalculateExecutionContext (exe_ctx);
Greg Clayton62afb9f2013-11-04 19:35:17 +00001520 EvaluateExpressionOptions expr_options;
1521 expr_options.SetUnwindOnError(true);
1522 expr_options.SetIgnoreBreakpoints(true);
1523 expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
Greg Clayton8f343b02010-11-04 01:54:29 +00001524 StreamString expr;
Greg Clayton8f343b02010-11-04 01:54:29 +00001525 expr.Printf("dlopen (\"%s\", 2)", path);
1526 const char *prefix = "extern \"C\" void* dlopen (const char *path, int mode);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001527 lldb::ValueObjectSP result_valobj_sp;
Greg Clayton62afb9f2013-11-04 19:35:17 +00001528 Error expr_error;
Greg Clayton26ab83d2012-10-31 20:49:04 +00001529 ClangUserExpression::Evaluate (exe_ctx,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001530 expr_options,
Greg Clayton26ab83d2012-10-31 20:49:04 +00001531 expr.GetData(),
1532 prefix,
1533 result_valobj_sp,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001534 expr_error);
1535 if (expr_error.Success())
Greg Clayton8f343b02010-11-04 01:54:29 +00001536 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001537 error = result_valobj_sp->GetError();
1538 if (error.Success())
Greg Clayton8f343b02010-11-04 01:54:29 +00001539 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001540 Scalar scalar;
1541 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001542 {
Greg Clayton62afb9f2013-11-04 19:35:17 +00001543 addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1544 if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
1545 {
1546 uint32_t image_token = m_image_tokens.size();
1547 m_image_tokens.push_back (image_ptr);
1548 return image_token;
1549 }
Greg Clayton8f343b02010-11-04 01:54:29 +00001550 }
1551 }
1552 }
Jim Ingham6c9ed912014-04-03 01:26:14 +00001553 else
1554 error = expr_error;
Greg Clayton8f343b02010-11-04 01:54:29 +00001555 }
1556 }
1557 }
Greg Claytonac7a3db2012-04-18 00:05:19 +00001558 if (!error.AsCString())
1559 error.SetErrorStringWithFormat("unable to load '%s'", path);
Greg Clayton8f343b02010-11-04 01:54:29 +00001560 return LLDB_INVALID_IMAGE_TOKEN;
1561}
1562
1563//----------------------------------------------------------------------
1564// UnloadImage
1565//
1566// This function provides a default implementation that works for most
1567// unix variants. Any Process subclasses that need to do shared library
1568// loading differently should override LoadImage and UnloadImage and
1569// do what is needed.
1570//----------------------------------------------------------------------
1571Error
1572Process::UnloadImage (uint32_t image_token)
1573{
1574 Error error;
1575 if (image_token < m_image_tokens.size())
1576 {
1577 const addr_t image_addr = m_image_tokens[image_token];
1578 if (image_addr == LLDB_INVALID_ADDRESS)
1579 {
1580 error.SetErrorString("image already unloaded");
1581 }
1582 else
1583 {
1584 DynamicLoader *loader = GetDynamicLoader();
1585 if (loader)
1586 error = loader->CanLoadImage();
1587
1588 if (error.Success())
1589 {
1590 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
Greg Clayton8f343b02010-11-04 01:54:29 +00001591
1592 if (thread_sp)
1593 {
Jason Molendab57e4a12013-11-04 09:33:30 +00001594 StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
Greg Clayton8f343b02010-11-04 01:54:29 +00001595
1596 if (frame_sp)
1597 {
1598 ExecutionContext exe_ctx;
1599 frame_sp->CalculateExecutionContext (exe_ctx);
Greg Clayton62afb9f2013-11-04 19:35:17 +00001600 EvaluateExpressionOptions expr_options;
1601 expr_options.SetUnwindOnError(true);
1602 expr_options.SetIgnoreBreakpoints(true);
1603 expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
Greg Clayton8f343b02010-11-04 01:54:29 +00001604 StreamString expr;
Daniel Malead01b2952012-11-29 21:49:15 +00001605 expr.Printf("dlclose ((void *)0x%" PRIx64 ")", image_addr);
Greg Clayton8f343b02010-11-04 01:54:29 +00001606 const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
Jim Inghamf48169b2010-11-30 02:22:11 +00001607 lldb::ValueObjectSP result_valobj_sp;
Greg Clayton62afb9f2013-11-04 19:35:17 +00001608 Error expr_error;
Greg Clayton26ab83d2012-10-31 20:49:04 +00001609 ClangUserExpression::Evaluate (exe_ctx,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001610 expr_options,
Greg Clayton26ab83d2012-10-31 20:49:04 +00001611 expr.GetData(),
1612 prefix,
1613 result_valobj_sp,
Greg Clayton62afb9f2013-11-04 19:35:17 +00001614 expr_error);
Greg Clayton8f343b02010-11-04 01:54:29 +00001615 if (result_valobj_sp->GetError().Success())
1616 {
1617 Scalar scalar;
Jim Ingham6035b672011-03-31 00:19:25 +00001618 if (result_valobj_sp->ResolveValue (scalar))
Greg Clayton8f343b02010-11-04 01:54:29 +00001619 {
1620 if (scalar.UInt(1))
1621 {
1622 error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData());
1623 }
1624 else
1625 {
1626 m_image_tokens[image_token] = LLDB_INVALID_ADDRESS;
1627 }
1628 }
1629 }
1630 else
1631 {
1632 error = result_valobj_sp->GetError();
1633 }
1634 }
1635 }
1636 }
1637 }
1638 }
1639 else
1640 {
1641 error.SetErrorString("invalid image token");
1642 }
1643 return error;
1644}
1645
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001646const lldb::ABISP &
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001647Process::GetABI()
1648{
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001649 if (!m_abi_sp)
1650 m_abi_sp = ABI::FindPlugin(m_target.GetArchitecture());
1651 return m_abi_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001652}
1653
Jim Ingham22777012010-09-23 02:01:19 +00001654LanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001655Process::GetLanguageRuntime(lldb::LanguageType language, bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001656{
1657 LanguageRuntimeCollection::iterator pos;
1658 pos = m_language_runtimes.find (language);
Jim Inghamab175242012-03-10 00:22:19 +00001659 if (pos == m_language_runtimes.end() || (retry_if_null && !(*pos).second))
Jim Ingham22777012010-09-23 02:01:19 +00001660 {
Jim Inghamab175242012-03-10 00:22:19 +00001661 lldb::LanguageRuntimeSP runtime_sp(LanguageRuntime::FindPlugin(this, language));
Jim Ingham22777012010-09-23 02:01:19 +00001662
Jim Inghamab175242012-03-10 00:22:19 +00001663 m_language_runtimes[language] = runtime_sp;
1664 return runtime_sp.get();
Jim Ingham22777012010-09-23 02:01:19 +00001665 }
1666 else
1667 return (*pos).second.get();
1668}
1669
1670CPPLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001671Process::GetCPPLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001672{
Jim Inghamab175242012-03-10 00:22:19 +00001673 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus, retry_if_null);
Jim Ingham22777012010-09-23 02:01:19 +00001674 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
1675 return static_cast<CPPLanguageRuntime *> (runtime);
1676 return NULL;
1677}
1678
1679ObjCLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001680Process::GetObjCLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001681{
Jim Inghamab175242012-03-10 00:22:19 +00001682 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC, retry_if_null);
Jim Ingham22777012010-09-23 02:01:19 +00001683 if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC)
1684 return static_cast<ObjCLanguageRuntime *> (runtime);
1685 return NULL;
1686}
1687
Enrico Granatafd4c84e2012-05-21 16:51:35 +00001688bool
1689Process::IsPossibleDynamicValue (ValueObject& in_value)
1690{
1691 if (in_value.IsDynamic())
1692 return false;
1693 LanguageType known_type = in_value.GetObjectRuntimeLanguage();
1694
1695 if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC)
1696 {
1697 LanguageRuntime *runtime = GetLanguageRuntime (known_type);
1698 return runtime ? runtime->CouldHaveDynamicValue(in_value) : false;
1699 }
1700
1701 LanguageRuntime *cpp_runtime = GetLanguageRuntime (eLanguageTypeC_plus_plus);
1702 if (cpp_runtime && cpp_runtime->CouldHaveDynamicValue(in_value))
1703 return true;
1704
1705 LanguageRuntime *objc_runtime = GetLanguageRuntime (eLanguageTypeObjC);
1706 return objc_runtime ? objc_runtime->CouldHaveDynamicValue(in_value) : false;
1707}
1708
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001709BreakpointSiteList &
1710Process::GetBreakpointSiteList()
1711{
1712 return m_breakpoint_site_list;
1713}
1714
1715const BreakpointSiteList &
1716Process::GetBreakpointSiteList() const
1717{
1718 return m_breakpoint_site_list;
1719}
1720
1721
1722void
1723Process::DisableAllBreakpointSites ()
1724{
Greg Claytond8cf1a12013-06-12 00:46:38 +00001725 m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void {
1726// bp_site->SetEnabled(true);
1727 DisableBreakpointSite(bp_site);
1728 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001729}
1730
1731Error
1732Process::ClearBreakpointSiteByID (lldb::user_id_t break_id)
1733{
1734 Error error (DisableBreakpointSiteByID (break_id));
1735
1736 if (error.Success())
1737 m_breakpoint_site_list.Remove(break_id);
1738
1739 return error;
1740}
1741
1742Error
1743Process::DisableBreakpointSiteByID (lldb::user_id_t break_id)
1744{
1745 Error error;
1746 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1747 if (bp_site_sp)
1748 {
1749 if (bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00001750 error = DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001751 }
1752 else
1753 {
Daniel Malead01b2952012-11-29 21:49:15 +00001754 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001755 }
1756
1757 return error;
1758}
1759
1760Error
1761Process::EnableBreakpointSiteByID (lldb::user_id_t break_id)
1762{
1763 Error error;
1764 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1765 if (bp_site_sp)
1766 {
1767 if (!bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00001768 error = EnableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001769 }
1770 else
1771 {
Daniel Malead01b2952012-11-29 21:49:15 +00001772 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001773 }
1774 return error;
1775}
1776
Stephen Wilson50bd94f2010-07-17 00:56:13 +00001777lldb::break_id_t
Greg Claytone1cd1be2012-01-29 20:56:30 +00001778Process::CreateBreakpointSite (const BreakpointLocationSP &owner, bool use_hardware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001779{
Jim Ingham1460e4b2014-01-10 23:46:59 +00001780 addr_t load_addr = LLDB_INVALID_ADDRESS;
1781
1782 bool show_error = true;
1783 switch (GetState())
1784 {
1785 case eStateInvalid:
1786 case eStateUnloaded:
1787 case eStateConnected:
1788 case eStateAttaching:
1789 case eStateLaunching:
1790 case eStateDetached:
1791 case eStateExited:
1792 show_error = false;
1793 break;
1794
1795 case eStateStopped:
1796 case eStateRunning:
1797 case eStateStepping:
1798 case eStateCrashed:
1799 case eStateSuspended:
1800 show_error = IsAlive();
1801 break;
1802 }
1803
1804 // Reset the IsIndirect flag here, in case the location changes from
1805 // pointing to a indirect symbol to a regular symbol.
1806 owner->SetIsIndirect (false);
1807
1808 if (owner->ShouldResolveIndirectFunctions())
1809 {
1810 Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
1811 if (symbol && symbol->IsIndirect())
1812 {
1813 Error error;
1814 load_addr = ResolveIndirectFunction (&symbol->GetAddress(), error);
1815 if (!error.Success() && show_error)
1816 {
Greg Clayton44d93782014-01-27 23:43:24 +00001817 m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to resolve indirect function at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
1818 symbol->GetAddress().GetLoadAddress(&m_target),
1819 owner->GetBreakpoint().GetID(),
1820 owner->GetID(),
1821 error.AsCString() ? error.AsCString() : "unkown error");
Jim Ingham1460e4b2014-01-10 23:46:59 +00001822 return LLDB_INVALID_BREAK_ID;
1823 }
1824 Address resolved_address(load_addr);
1825 load_addr = resolved_address.GetOpcodeLoadAddress (&m_target);
1826 owner->SetIsIndirect(true);
1827 }
1828 else
1829 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
1830 }
1831 else
1832 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
1833
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001834 if (load_addr != LLDB_INVALID_ADDRESS)
1835 {
1836 BreakpointSiteSP bp_site_sp;
1837
1838 // Look up this breakpoint site. If it exists, then add this new owner, otherwise
1839 // create a new breakpoint site and add it.
1840
1841 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr);
1842
1843 if (bp_site_sp)
1844 {
1845 bp_site_sp->AddOwner (owner);
1846 owner->SetBreakpointSite (bp_site_sp);
1847 return bp_site_sp->GetID();
1848 }
1849 else
1850 {
Greg Claytonc7bece562013-01-25 18:06:21 +00001851 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, use_hardware));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001852 if (bp_site_sp)
1853 {
Greg Claytoneb023e72013-10-11 19:48:25 +00001854 Error error = EnableBreakpointSite (bp_site_sp.get());
1855 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001856 {
1857 owner->SetBreakpointSite (bp_site_sp);
1858 return m_breakpoint_site_list.Add (bp_site_sp);
1859 }
Greg Claytoneb023e72013-10-11 19:48:25 +00001860 else
1861 {
Greg Claytonfbb76342013-11-20 21:07:01 +00001862 if (show_error)
1863 {
1864 // Report error for setting breakpoint...
Greg Clayton44d93782014-01-27 23:43:24 +00001865 m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to set breakpoint site at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
1866 load_addr,
1867 owner->GetBreakpoint().GetID(),
1868 owner->GetID(),
1869 error.AsCString() ? error.AsCString() : "unkown error");
Greg Claytonfbb76342013-11-20 21:07:01 +00001870 }
Greg Claytoneb023e72013-10-11 19:48:25 +00001871 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001872 }
1873 }
1874 }
1875 // We failed to enable the breakpoint
1876 return LLDB_INVALID_BREAK_ID;
1877
1878}
1879
1880void
1881Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp)
1882{
1883 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id);
1884 if (num_owners == 0)
1885 {
Jim Inghamf1ff3bb2013-04-06 00:16:39 +00001886 // Don't try to disable the site if we don't have a live process anymore.
1887 if (IsAlive())
1888 DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001889 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
1890 }
1891}
1892
1893
1894size_t
1895Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
1896{
1897 size_t bytes_removed = 0;
Jim Ingham20c77192011-06-29 19:42:28 +00001898 BreakpointSiteList bp_sites_in_range;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001899
Jim Ingham20c77192011-06-29 19:42:28 +00001900 if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001901 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00001902 bp_sites_in_range.ForEach([bp_addr, size, buf, &bytes_removed](BreakpointSite *bp_site) -> void {
1903 if (bp_site->GetType() == BreakpointSite::eSoftware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001904 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00001905 addr_t intersect_addr;
1906 size_t intersect_size;
1907 size_t opcode_offset;
1908 if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset))
Jim Ingham20c77192011-06-29 19:42:28 +00001909 {
1910 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
1911 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size);
Greg Claytond8cf1a12013-06-12 00:46:38 +00001912 assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
Jim Ingham20c77192011-06-29 19:42:28 +00001913 size_t buf_offset = intersect_addr - bp_addr;
Greg Claytond8cf1a12013-06-12 00:46:38 +00001914 ::memcpy(buf + buf_offset, bp_site->GetSavedOpcodeBytes() + opcode_offset, intersect_size);
Jim Ingham20c77192011-06-29 19:42:28 +00001915 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001916 }
Greg Claytond8cf1a12013-06-12 00:46:38 +00001917 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001918 }
1919 return bytes_removed;
1920}
1921
1922
Greg Claytonded470d2011-03-19 01:12:21 +00001923
1924size_t
1925Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
1926{
1927 PlatformSP platform_sp (m_target.GetPlatform());
1928 if (platform_sp)
1929 return platform_sp->GetSoftwareBreakpointTrapOpcode (m_target, bp_site);
1930 return 0;
1931}
1932
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001933Error
1934Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site)
1935{
1936 Error error;
1937 assert (bp_site != NULL);
Greg Clayton5160ce52013-03-27 23:08:40 +00001938 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001939 const addr_t bp_addr = bp_site->GetLoadAddress();
1940 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001941 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64, bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001942 if (bp_site->IsEnabled())
1943 {
1944 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001945 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 +00001946 return error;
1947 }
1948
1949 if (bp_addr == LLDB_INVALID_ADDRESS)
1950 {
1951 error.SetErrorString("BreakpointSite contains an invalid load address.");
1952 return error;
1953 }
1954 // Ask the lldb::Process subclass to fill in the correct software breakpoint
1955 // trap for the breakpoint site
1956 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
1957
1958 if (bp_opcode_size == 0)
1959 {
Daniel Malead01b2952012-11-29 21:49:15 +00001960 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%" PRIx64, bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001961 }
1962 else
1963 {
1964 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
1965
1966 if (bp_opcode_bytes == NULL)
1967 {
1968 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode.");
1969 return error;
1970 }
1971
1972 // Save the original opcode by reading it
1973 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size)
1974 {
1975 // Write a software breakpoint in place of the original opcode
1976 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
1977 {
1978 uint8_t verify_bp_opcode_bytes[64];
1979 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
1980 {
1981 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0)
1982 {
1983 bp_site->SetEnabled(true);
1984 bp_site->SetType (BreakpointSite::eSoftware);
1985 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00001986 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001987 bp_site->GetID(),
1988 (uint64_t)bp_addr);
1989 }
1990 else
Greg Clayton86edbf42011-10-26 00:56:27 +00001991 error.SetErrorString("failed to verify the breakpoint trap in memory.");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001992 }
1993 else
1994 error.SetErrorString("Unable to read memory to verify breakpoint trap.");
1995 }
1996 else
1997 error.SetErrorString("Unable to write breakpoint trap to memory.");
1998 }
1999 else
2000 error.SetErrorString("Unable to read memory at breakpoint address.");
2001 }
Stephen Wilson78a4feb2011-01-12 04:20:03 +00002002 if (log && error.Fail())
Daniel Malead01b2952012-11-29 21:49:15 +00002003 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002004 bp_site->GetID(),
2005 (uint64_t)bp_addr,
2006 error.AsCString());
2007 return error;
2008}
2009
2010Error
2011Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
2012{
2013 Error error;
2014 assert (bp_site != NULL);
Greg Clayton5160ce52013-03-27 23:08:40 +00002015 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002016 addr_t bp_addr = bp_site->GetLoadAddress();
2017 lldb::user_id_t breakID = bp_site->GetID();
2018 if (log)
Jim Ingham299c0c12013-02-15 02:06:30 +00002019 log->Printf ("Process::DisableSoftwareBreakpoint (breakID = %" PRIu64 ") addr = 0x%" PRIx64, breakID, (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002020
2021 if (bp_site->IsHardware())
2022 {
2023 error.SetErrorString("Breakpoint site is a hardware breakpoint.");
2024 }
2025 else if (bp_site->IsEnabled())
2026 {
2027 const size_t break_op_size = bp_site->GetByteSize();
2028 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
2029 if (break_op_size > 0)
2030 {
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00002031 // Clear a software breakpoint instruction
Greg Claytonc982c762010-07-09 20:39:50 +00002032 uint8_t curr_break_op[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002033 assert (break_op_size <= sizeof(curr_break_op));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002034 bool break_op_found = false;
2035
2036 // Read the breakpoint opcode
2037 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
2038 {
2039 bool verify = false;
2040 // Make sure we have the a breakpoint opcode exists at this address
2041 if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
2042 {
2043 break_op_found = true;
2044 // We found a valid breakpoint opcode at this address, now restore
2045 // the saved opcode.
2046 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size)
2047 {
2048 verify = true;
2049 }
2050 else
2051 error.SetErrorString("Memory write failed when restoring original opcode.");
2052 }
2053 else
2054 {
2055 error.SetErrorString("Original breakpoint trap is no longer in memory.");
2056 // Set verify to true and so we can check if the original opcode has already been restored
2057 verify = true;
2058 }
2059
2060 if (verify)
2061 {
Greg Claytonc982c762010-07-09 20:39:50 +00002062 uint8_t verify_opcode[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002063 assert (break_op_size < sizeof(verify_opcode));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002064 // Verify that our original opcode made it back to the inferior
2065 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size)
2066 {
2067 // compare the memory we just read with the original opcode
2068 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
2069 {
2070 // SUCCESS
2071 bp_site->SetEnabled(false);
2072 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002073 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 +00002074 return error;
2075 }
2076 else
2077 {
2078 if (break_op_found)
2079 error.SetErrorString("Failed to restore original opcode.");
2080 }
2081 }
2082 else
2083 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored.");
2084 }
2085 }
2086 else
2087 error.SetErrorString("Unable to read memory that should contain the breakpoint trap.");
2088 }
2089 }
2090 else
2091 {
2092 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002093 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 +00002094 return error;
2095 }
2096
2097 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002098 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002099 bp_site->GetID(),
2100 (uint64_t)bp_addr,
2101 error.AsCString());
2102 return error;
2103
2104}
2105
Greg Clayton58be07b2011-01-07 06:08:19 +00002106// Uncomment to verify memory caching works after making changes to caching code
2107//#define VERIFY_MEMORY_READS
2108
Sean Callanan64c0cf22012-06-07 22:26:42 +00002109size_t
2110Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
2111{
Jason Molendaa7b5afa2013-11-15 00:17:32 +00002112 error.Clear();
Sean Callanan64c0cf22012-06-07 22:26:42 +00002113 if (!GetDisableMemoryCache())
2114 {
Greg Clayton58be07b2011-01-07 06:08:19 +00002115#if defined (VERIFY_MEMORY_READS)
Sean Callanan64c0cf22012-06-07 22:26:42 +00002116 // Memory caching is enabled, with debug verification
2117
2118 if (buf && size)
2119 {
2120 // Uncomment the line below to make sure memory caching is working.
2121 // I ran this through the test suite and got no assertions, so I am
2122 // pretty confident this is working well. If any changes are made to
2123 // memory caching, uncomment the line below and test your changes!
2124
2125 // Verify all memory reads by using the cache first, then redundantly
2126 // reading the same memory from the inferior and comparing to make sure
2127 // everything is exactly the same.
2128 std::string verify_buf (size, '\0');
2129 assert (verify_buf.size() == size);
2130 const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error);
2131 Error verify_error;
2132 const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error);
2133 assert (cache_bytes_read == verify_bytes_read);
2134 assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
2135 assert (verify_error.Success() == error.Success());
2136 return cache_bytes_read;
2137 }
2138 return 0;
2139#else // !defined(VERIFY_MEMORY_READS)
2140 // Memory caching is enabled, without debug verification
2141
2142 return m_memory_cache.Read (addr, buf, size, error);
2143#endif // defined (VERIFY_MEMORY_READS)
Greg Clayton58be07b2011-01-07 06:08:19 +00002144 }
Sean Callanan64c0cf22012-06-07 22:26:42 +00002145 else
2146 {
2147 // Memory caching is disabled
2148
2149 return ReadMemoryFromInferior (addr, buf, size, error);
2150 }
Greg Clayton58be07b2011-01-07 06:08:19 +00002151}
Greg Clayton58be07b2011-01-07 06:08:19 +00002152
Greg Clayton4c82d422012-05-18 23:20:01 +00002153size_t
2154Process::ReadCStringFromMemory (addr_t addr, std::string &out_str, Error &error)
2155{
Greg Claytonde87c0f2012-05-19 00:18:00 +00002156 char buf[256];
Greg Clayton4c82d422012-05-18 23:20:01 +00002157 out_str.clear();
2158 addr_t curr_addr = addr;
2159 while (1)
2160 {
2161 size_t length = ReadCStringFromMemory (curr_addr, buf, sizeof(buf), error);
2162 if (length == 0)
2163 break;
2164 out_str.append(buf, length);
2165 // If we got "length - 1" bytes, we didn't get the whole C string, we
2166 // need to read some more characters
2167 if (length == sizeof(buf) - 1)
2168 curr_addr += length;
2169 else
2170 break;
2171 }
2172 return out_str.size();
2173}
2174
Greg Clayton58be07b2011-01-07 06:08:19 +00002175
2176size_t
Ashok Thirumurthi6ac9d132013-04-19 15:58:38 +00002177Process::ReadStringFromMemory (addr_t addr, char *dst, size_t max_bytes, Error &error,
2178 size_t type_width)
2179{
2180 size_t total_bytes_read = 0;
2181 if (dst && max_bytes && type_width && max_bytes >= type_width)
2182 {
2183 // Ensure a null terminator independent of the number of bytes that is read.
2184 memset (dst, 0, max_bytes);
2185 size_t bytes_left = max_bytes - type_width;
2186
2187 const char terminator[4] = {'\0', '\0', '\0', '\0'};
2188 assert(sizeof(terminator) >= type_width &&
2189 "Attempting to validate a string with more than 4 bytes per character!");
2190
2191 addr_t curr_addr = addr;
2192 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2193 char *curr_dst = dst;
2194
2195 error.Clear();
2196 while (bytes_left > 0 && error.Success())
2197 {
2198 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2199 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2200 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2201
2202 if (bytes_read == 0)
2203 break;
2204
2205 // Search for a null terminator of correct size and alignment in bytes_read
2206 size_t aligned_start = total_bytes_read - total_bytes_read % type_width;
2207 for (size_t i = aligned_start; i + type_width <= total_bytes_read + bytes_read; i += type_width)
2208 if (::strncmp(&dst[i], terminator, type_width) == 0)
2209 {
2210 error.Clear();
2211 return i;
2212 }
2213
2214 total_bytes_read += bytes_read;
2215 curr_dst += bytes_read;
2216 curr_addr += bytes_read;
2217 bytes_left -= bytes_read;
2218 }
2219 }
2220 else
2221 {
2222 if (max_bytes)
2223 error.SetErrorString("invalid arguments");
2224 }
2225 return total_bytes_read;
2226}
2227
2228// Deprecated in favor of ReadStringFromMemory which has wchar support and correct code to find
2229// null terminators.
2230size_t
Greg Claytone91b7952011-12-15 03:14:23 +00002231Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len, Error &result_error)
Greg Clayton8b82f082011-04-12 05:54:46 +00002232{
2233 size_t total_cstr_len = 0;
2234 if (dst && dst_max_len)
2235 {
Greg Claytone91b7952011-12-15 03:14:23 +00002236 result_error.Clear();
Greg Clayton8b82f082011-04-12 05:54:46 +00002237 // NULL out everything just to be safe
2238 memset (dst, 0, dst_max_len);
2239 Error error;
2240 addr_t curr_addr = addr;
2241 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2242 size_t bytes_left = dst_max_len - 1;
2243 char *curr_dst = dst;
2244
2245 while (bytes_left > 0)
2246 {
2247 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2248 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2249 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2250
2251 if (bytes_read == 0)
2252 {
Greg Claytone91b7952011-12-15 03:14:23 +00002253 result_error = error;
Greg Clayton8b82f082011-04-12 05:54:46 +00002254 dst[total_cstr_len] = '\0';
2255 break;
2256 }
2257 const size_t len = strlen(curr_dst);
2258
2259 total_cstr_len += len;
2260
2261 if (len < bytes_to_read)
2262 break;
2263
2264 curr_dst += bytes_read;
2265 curr_addr += bytes_read;
2266 bytes_left -= bytes_read;
2267 }
2268 }
Greg Claytone91b7952011-12-15 03:14:23 +00002269 else
2270 {
2271 if (dst == NULL)
2272 result_error.SetErrorString("invalid arguments");
2273 else
2274 result_error.Clear();
2275 }
Greg Clayton8b82f082011-04-12 05:54:46 +00002276 return total_cstr_len;
2277}
2278
2279size_t
Greg Clayton58be07b2011-01-07 06:08:19 +00002280Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error)
2281{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002282 if (buf == NULL || size == 0)
2283 return 0;
2284
2285 size_t bytes_read = 0;
2286 uint8_t *bytes = (uint8_t *)buf;
2287
2288 while (bytes_read < size)
2289 {
2290 const size_t curr_size = size - bytes_read;
2291 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read,
2292 bytes + bytes_read,
2293 curr_size,
2294 error);
2295 bytes_read += curr_bytes_read;
2296 if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2297 break;
2298 }
2299
2300 // Replace any software breakpoint opcodes that fall into this range back
2301 // into "buf" before we return
2302 if (bytes_read > 0)
2303 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf);
2304 return bytes_read;
2305}
2306
Greg Clayton58a4c462010-12-16 20:01:20 +00002307uint64_t
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002308Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error)
Greg Clayton58a4c462010-12-16 20:01:20 +00002309{
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002310 Scalar scalar;
2311 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error))
2312 return scalar.ULongLong(fail_value);
2313 return fail_value;
2314}
2315
2316addr_t
2317Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
2318{
2319 Scalar scalar;
2320 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error))
2321 return scalar.ULongLong(LLDB_INVALID_ADDRESS);
2322 return LLDB_INVALID_ADDRESS;
2323}
2324
2325
2326bool
2327Process::WritePointerToMemory (lldb::addr_t vm_addr,
2328 lldb::addr_t ptr_value,
2329 Error &error)
2330{
2331 Scalar scalar;
2332 const uint32_t addr_byte_size = GetAddressByteSize();
2333 if (addr_byte_size <= 4)
2334 scalar = (uint32_t)ptr_value;
Greg Clayton58a4c462010-12-16 20:01:20 +00002335 else
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002336 scalar = ptr_value;
2337 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size;
Greg Clayton58a4c462010-12-16 20:01:20 +00002338}
2339
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002340size_t
2341Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error)
2342{
2343 size_t bytes_written = 0;
2344 const uint8_t *bytes = (const uint8_t *)buf;
2345
2346 while (bytes_written < size)
2347 {
2348 const size_t curr_size = size - bytes_written;
2349 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written,
2350 bytes + bytes_written,
2351 curr_size,
2352 error);
2353 bytes_written += curr_bytes_written;
2354 if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2355 break;
2356 }
2357 return bytes_written;
2358}
2359
2360size_t
2361Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
2362{
Greg Clayton58be07b2011-01-07 06:08:19 +00002363#if defined (ENABLE_MEMORY_CACHING)
2364 m_memory_cache.Flush (addr, size);
2365#endif
2366
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002367 if (buf == NULL || size == 0)
2368 return 0;
Jim Ingham78a685a2011-04-16 00:01:13 +00002369
Jim Ingham4b536182011-08-09 02:12:22 +00002370 m_mod_id.BumpMemoryID();
Jim Ingham78a685a2011-04-16 00:01:13 +00002371
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002372 // We need to write any data that would go where any current software traps
2373 // (enabled software breakpoints) any software traps (breakpoints) that we
2374 // may have placed in our tasks memory.
2375
Greg Claytond8cf1a12013-06-12 00:46:38 +00002376 BreakpointSiteList bp_sites_in_range;
2377
2378 if (m_breakpoint_site_list.FindInRange (addr, addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002379 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002380 // No breakpoint sites overlap
2381 if (bp_sites_in_range.IsEmpty())
2382 return WriteMemoryPrivate (addr, buf, size, error);
2383 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002384 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002385 const uint8_t *ubuf = (const uint8_t *)buf;
2386 uint64_t bytes_written = 0;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002387
Greg Claytond8cf1a12013-06-12 00:46:38 +00002388 bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, &error](BreakpointSite *bp) -> void {
2389
2390 if (error.Success())
2391 {
2392 addr_t intersect_addr;
2393 size_t intersect_size;
2394 size_t opcode_offset;
2395 const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
2396 assert(intersects);
2397 assert(addr <= intersect_addr && intersect_addr < addr + size);
2398 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
2399 assert(opcode_offset + intersect_size <= bp->GetByteSize());
2400
2401 // Check for bytes before this breakpoint
2402 const addr_t curr_addr = addr + bytes_written;
2403 if (intersect_addr > curr_addr)
2404 {
2405 // There are some bytes before this breakpoint that we need to
2406 // just write to memory
2407 size_t curr_size = intersect_addr - curr_addr;
2408 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr,
2409 ubuf + bytes_written,
2410 curr_size,
2411 error);
2412 bytes_written += curr_bytes_written;
2413 if (curr_bytes_written != curr_size)
2414 {
2415 // We weren't able to write all of the requested bytes, we
2416 // are done looping and will return the number of bytes that
2417 // we have written so far.
2418 if (error.Success())
2419 error.SetErrorToGenericError();
2420 }
2421 }
2422 // Now write any bytes that would cover up any software breakpoints
2423 // directly into the breakpoint opcode buffer
2424 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
2425 bytes_written += intersect_size;
2426 }
2427 });
2428
2429 if (bytes_written < size)
2430 bytes_written += WriteMemoryPrivate (addr + bytes_written,
2431 ubuf + bytes_written,
2432 size - bytes_written,
2433 error);
2434 }
2435 }
2436 else
2437 {
2438 return WriteMemoryPrivate (addr, buf, size, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002439 }
2440
2441 // Write any remaining bytes after the last breakpoint if we have any left
Greg Claytond8cf1a12013-06-12 00:46:38 +00002442 return 0; //bytes_written;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002443}
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002444
2445size_t
Greg Claytonc7bece562013-01-25 18:06:21 +00002446Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, size_t byte_size, Error &error)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002447{
2448 if (byte_size == UINT32_MAX)
2449 byte_size = scalar.GetByteSize();
2450 if (byte_size > 0)
2451 {
2452 uint8_t buf[32];
2453 const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error);
2454 if (mem_size > 0)
2455 return WriteMemory(addr, buf, mem_size, error);
2456 else
2457 error.SetErrorString ("failed to get scalar as memory data");
2458 }
2459 else
2460 {
2461 error.SetErrorString ("invalid scalar value");
2462 }
2463 return 0;
2464}
2465
2466size_t
2467Process::ReadScalarIntegerFromMemory (addr_t addr,
2468 uint32_t byte_size,
2469 bool is_signed,
2470 Scalar &scalar,
2471 Error &error)
2472{
Greg Clayton7060f892013-05-01 23:41:30 +00002473 uint64_t uval = 0;
2474 if (byte_size == 0)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002475 {
Greg Clayton7060f892013-05-01 23:41:30 +00002476 error.SetErrorString ("byte size is zero");
2477 }
2478 else if (byte_size & (byte_size - 1))
2479 {
2480 error.SetErrorStringWithFormat ("byte size %u is not a power of 2", byte_size);
2481 }
2482 else if (byte_size <= sizeof(uval))
2483 {
2484 const size_t bytes_read = ReadMemory (addr, &uval, byte_size, error);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002485 if (bytes_read == byte_size)
2486 {
2487 DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize());
Greg Claytonc7bece562013-01-25 18:06:21 +00002488 lldb::offset_t offset = 0;
Greg Clayton7060f892013-05-01 23:41:30 +00002489 if (byte_size <= 4)
2490 scalar = data.GetMaxU32 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002491 else
Greg Clayton7060f892013-05-01 23:41:30 +00002492 scalar = data.GetMaxU64 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002493 if (is_signed)
2494 scalar.SignExtend(byte_size * 8);
2495 return bytes_read;
2496 }
2497 }
2498 else
2499 {
2500 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
2501 }
2502 return 0;
2503}
2504
Greg Claytond495c532011-05-17 03:37:42 +00002505#define USE_ALLOCATE_MEMORY_CACHE 1
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002506addr_t
2507Process::AllocateMemory(size_t size, uint32_t permissions, Error &error)
2508{
Jim Inghamf72ce3a2011-06-20 17:32:44 +00002509 if (GetPrivateState() != eStateStopped)
2510 return LLDB_INVALID_ADDRESS;
2511
Greg Claytond495c532011-05-17 03:37:42 +00002512#if defined (USE_ALLOCATE_MEMORY_CACHE)
2513 return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2514#else
Greg Claytonb2daec92011-01-23 19:58:49 +00002515 addr_t allocated_addr = DoAllocateMemory (size, permissions, error);
Greg Clayton5160ce52013-03-27 23:08:40 +00002516 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002517 if (log)
Greg Clayton45989072013-10-23 18:24:30 +00002518 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 +00002519 (uint64_t)size,
Greg Claytond495c532011-05-17 03:37:42 +00002520 GetPermissionsAsCString (permissions),
Greg Claytonb2daec92011-01-23 19:58:49 +00002521 (uint64_t)allocated_addr,
Jim Ingham4b536182011-08-09 02:12:22 +00002522 m_mod_id.GetStopID(),
2523 m_mod_id.GetMemoryID());
Greg Claytonb2daec92011-01-23 19:58:49 +00002524 return allocated_addr;
Greg Claytond495c532011-05-17 03:37:42 +00002525#endif
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002526}
2527
Sean Callanan90539452011-09-20 23:01:51 +00002528bool
2529Process::CanJIT ()
2530{
Sean Callanana7b443a2012-02-14 22:50:38 +00002531 if (m_can_jit == eCanJITDontKnow)
2532 {
Todd Fialaaf245d12014-06-30 21:05:18 +00002533 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Sean Callanana7b443a2012-02-14 22:50:38 +00002534 Error err;
2535
2536 uint64_t allocated_memory = AllocateMemory(8,
2537 ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
2538 err);
2539
2540 if (err.Success())
Todd Fialaaf245d12014-06-30 21:05:18 +00002541 {
Sean Callanana7b443a2012-02-14 22:50:38 +00002542 m_can_jit = eCanJITYes;
Todd Fialaaf245d12014-06-30 21:05:18 +00002543 if (log)
2544 log->Printf ("Process::%s pid %" PRIu64 " allocation test passed, CanJIT () is true", __FUNCTION__, GetID ());
2545 }
Sean Callanana7b443a2012-02-14 22:50:38 +00002546 else
Todd Fialaaf245d12014-06-30 21:05:18 +00002547 {
Sean Callanana7b443a2012-02-14 22:50:38 +00002548 m_can_jit = eCanJITNo;
Todd Fialaaf245d12014-06-30 21:05:18 +00002549 if (log)
2550 log->Printf ("Process::%s pid %" PRIu64 " allocation test failed, CanJIT () is false: %s", __FUNCTION__, GetID (), err.AsCString ());
2551 }
Sean Callanana7b443a2012-02-14 22:50:38 +00002552
2553 DeallocateMemory (allocated_memory);
2554 }
2555
Sean Callanan90539452011-09-20 23:01:51 +00002556 return m_can_jit == eCanJITYes;
2557}
2558
2559void
2560Process::SetCanJIT (bool can_jit)
2561{
2562 m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
2563}
2564
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002565Error
2566Process::DeallocateMemory (addr_t ptr)
2567{
Greg Claytond495c532011-05-17 03:37:42 +00002568 Error error;
2569#if defined (USE_ALLOCATE_MEMORY_CACHE)
2570 if (!m_allocated_memory_cache.DeallocateMemory(ptr))
2571 {
Daniel Malead01b2952012-11-29 21:49:15 +00002572 error.SetErrorStringWithFormat ("deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);
Greg Claytond495c532011-05-17 03:37:42 +00002573 }
2574#else
2575 error = DoDeallocateMemory (ptr);
Greg Claytonb2daec92011-01-23 19:58:49 +00002576
Greg Clayton5160ce52013-03-27 23:08:40 +00002577 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002578 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002579 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 +00002580 ptr,
2581 error.AsCString("SUCCESS"),
Jim Ingham4b536182011-08-09 02:12:22 +00002582 m_mod_id.GetStopID(),
2583 m_mod_id.GetMemoryID());
Greg Claytond495c532011-05-17 03:37:42 +00002584#endif
Greg Claytonb2daec92011-01-23 19:58:49 +00002585 return error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002586}
2587
Han Ming Ongc811d382012-11-17 00:33:14 +00002588
Greg Claytonc9660542012-02-05 02:38:54 +00002589ModuleSP
Greg Claytonc859e2d2012-02-13 23:10:39 +00002590Process::ReadModuleFromMemory (const FileSpec& file_spec,
Andrew MacPherson17220c12014-03-05 10:12:43 +00002591 lldb::addr_t header_addr,
2592 size_t size_to_read)
Greg Claytonc9660542012-02-05 02:38:54 +00002593{
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002594 ModuleSP module_sp (new Module (file_spec, ArchSpec()));
Greg Claytonc9660542012-02-05 02:38:54 +00002595 if (module_sp)
2596 {
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002597 Error error;
Andrew MacPherson17220c12014-03-05 10:12:43 +00002598 ObjectFile *objfile = module_sp->GetMemoryObjectFile (shared_from_this(), header_addr, error, size_to_read);
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002599 if (objfile)
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002600 return module_sp;
Greg Claytonc9660542012-02-05 02:38:54 +00002601 }
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002602 return ModuleSP();
Greg Claytonc9660542012-02-05 02:38:54 +00002603}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002604
2605Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002606Process::EnableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002607{
2608 Error error;
2609 error.SetErrorString("watchpoints are not supported");
2610 return error;
2611}
2612
2613Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002614Process::DisableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002615{
2616 Error error;
2617 error.SetErrorString("watchpoints are not supported");
2618 return error;
2619}
2620
2621StateType
2622Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp)
2623{
2624 StateType state;
2625 // Now wait for the process to launch and return control to us, and then
2626 // call DidLaunch:
2627 while (1)
2628 {
Greg Clayton6779606a2011-01-22 23:43:18 +00002629 event_sp.reset();
2630 state = WaitForStateChangedEventsPrivate (timeout, event_sp);
2631
Greg Clayton2637f822011-11-17 01:23:07 +00002632 if (StateIsStoppedState(state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002633 break;
Greg Clayton6779606a2011-01-22 23:43:18 +00002634
2635 // If state is invalid, then we timed out
2636 if (state == eStateInvalid)
2637 break;
2638
2639 if (event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002640 HandlePrivateEvent (event_sp);
2641 }
2642 return state;
2643}
2644
2645Error
Greg Claytonfbb76342013-11-20 21:07:01 +00002646Process::Launch (ProcessLaunchInfo &launch_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002647{
2648 Error error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002649 m_abi_sp.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002650 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002651 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00002652 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002653 m_os_ap.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002654 m_process_input_reader.reset();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002655
Greg Claytonaa149cb2011-08-11 02:48:45 +00002656 Module *exe_module = m_target.GetExecutableModulePointer();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002657 if (exe_module)
2658 {
Greg Clayton2289fa42011-04-30 01:09:13 +00002659 char local_exec_file_path[PATH_MAX];
2660 char platform_exec_file_path[PATH_MAX];
2661 exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path));
2662 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002663 if (exe_module->GetFileSpec().Exists())
2664 {
Greg Claytonfbb76342013-11-20 21:07:01 +00002665 // Install anything that might need to be installed prior to launching.
2666 // For host systems, this will do nothing, but if we are connected to a
2667 // remote platform it will install any needed binaries
2668 error = GetTarget().Install(&launch_info);
2669 if (error.Fail())
2670 return error;
2671
Greg Clayton71337622011-02-24 22:24:29 +00002672 if (PrivateStateThreadIsValid ())
2673 PausePrivateStateThread ();
2674
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002675 error = WillLaunch (exe_module);
2676 if (error.Success())
2677 {
Jim Ingham221d51c2013-05-08 00:35:16 +00002678 const bool restarted = false;
2679 SetPublicState (eStateLaunching, restarted);
Greg Claytone24c4ac2011-11-17 04:46:02 +00002680 m_should_detach = false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002681
Ed Maste64fad602013-07-29 20:58:06 +00002682 if (m_public_run_lock.TrySetRunning())
Greg Clayton69fd4be2012-09-04 20:29:05 +00002683 {
2684 // Now launch using these arguments.
2685 error = DoLaunch (exe_module, launch_info);
2686 }
2687 else
2688 {
2689 // This shouldn't happen
2690 error.SetErrorString("failed to acquire process run lock");
2691 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002692
2693 if (error.Fail())
2694 {
2695 if (GetID() != LLDB_INVALID_PROCESS_ID)
2696 {
2697 SetID (LLDB_INVALID_PROCESS_ID);
2698 const char *error_string = error.AsCString();
2699 if (error_string == NULL)
2700 error_string = "launch failed";
2701 SetExitStatus (-1, error_string);
2702 }
2703 }
2704 else
2705 {
2706 EventSP event_sp;
Greg Clayton1a38ea72011-06-22 01:42:17 +00002707 TimeValue timeout_time;
2708 timeout_time = TimeValue::Now();
2709 timeout_time.OffsetWithSeconds(10);
2710 StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002711
Greg Clayton1a38ea72011-06-22 01:42:17 +00002712 if (state == eStateInvalid || event_sp.get() == NULL)
2713 {
2714 // We were able to launch the process, but we failed to
2715 // catch the initial stop.
2716 SetExitStatus (0, "failed to catch stop after launch");
2717 Destroy();
2718 }
2719 else if (state == eStateStopped || state == eStateCrashed)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002720 {
Greg Clayton93d3c8332011-02-16 04:46:07 +00002721
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002722 DidLaunch ();
2723
Greg Claytonc859e2d2012-02-13 23:10:39 +00002724 DynamicLoader *dyld = GetDynamicLoader ();
2725 if (dyld)
2726 dyld->DidLaunch();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002727
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00002728 GetJITLoaders().DidLaunch();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002729
Jason Molendaeef51062013-11-05 03:57:19 +00002730 SystemRuntime *system_runtime = GetSystemRuntime ();
2731 if (system_runtime)
2732 system_runtime->DidLaunch();
2733
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002734 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002735 // This delays passing the stopped event to listeners till DidLaunch gets
2736 // a chance to complete...
2737 HandlePrivateEvent (event_sp);
Greg Clayton71337622011-02-24 22:24:29 +00002738
2739 if (PrivateStateThreadIsValid ())
2740 ResumePrivateStateThread ();
2741 else
2742 StartPrivateStateThread ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002743 }
2744 else if (state == eStateExited)
2745 {
2746 // We exited while trying to launch somehow. Don't call DidLaunch as that's
2747 // not likely to work, and return an invalid pid.
2748 HandlePrivateEvent (event_sp);
2749 }
2750 }
2751 }
2752 }
2753 else
2754 {
Greg Clayton86edbf42011-10-26 00:56:27 +00002755 error.SetErrorStringWithFormat("file doesn't exist: '%s'", local_exec_file_path);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002756 }
2757 }
2758 return error;
2759}
2760
Greg Claytonc3776bf2012-02-09 06:16:32 +00002761
2762Error
2763Process::LoadCore ()
2764{
2765 Error error = DoLoadCore();
2766 if (error.Success())
2767 {
2768 if (PrivateStateThreadIsValid ())
2769 ResumePrivateStateThread ();
2770 else
2771 StartPrivateStateThread ();
2772
Greg Claytonc859e2d2012-02-13 23:10:39 +00002773 DynamicLoader *dyld = GetDynamicLoader ();
2774 if (dyld)
2775 dyld->DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002776
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00002777 GetJITLoaders().DidAttach();
Greg Claytonc859e2d2012-02-13 23:10:39 +00002778
Jason Molendaeef51062013-11-05 03:57:19 +00002779 SystemRuntime *system_runtime = GetSystemRuntime ();
2780 if (system_runtime)
2781 system_runtime->DidAttach();
2782
Greg Claytonc859e2d2012-02-13 23:10:39 +00002783 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Greg Claytonc3776bf2012-02-09 06:16:32 +00002784 // We successfully loaded a core file, now pretend we stopped so we can
2785 // show all of the threads in the core file and explore the crashed
2786 // state.
2787 SetPrivateState (eStateStopped);
2788
2789 }
2790 return error;
2791}
2792
Greg Claytonc859e2d2012-02-13 23:10:39 +00002793DynamicLoader *
2794Process::GetDynamicLoader ()
2795{
2796 if (m_dyld_ap.get() == NULL)
2797 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
2798 return m_dyld_ap.get();
2799}
Greg Claytonc3776bf2012-02-09 06:16:32 +00002800
Todd Fialaaf245d12014-06-30 21:05:18 +00002801const lldb::DataBufferSP
2802Process::GetAuxvData()
2803{
2804 return DataBufferSP ();
2805}
2806
Andrew MacPherson17220c12014-03-05 10:12:43 +00002807JITLoaderList &
2808Process::GetJITLoaders ()
2809{
2810 if (!m_jit_loaders_ap)
2811 {
2812 m_jit_loaders_ap.reset(new JITLoaderList());
2813 JITLoader::LoadPlugins(this, *m_jit_loaders_ap);
2814 }
2815 return *m_jit_loaders_ap;
2816}
2817
Jason Molendaeef51062013-11-05 03:57:19 +00002818SystemRuntime *
2819Process::GetSystemRuntime ()
2820{
2821 if (m_system_runtime_ap.get() == NULL)
2822 m_system_runtime_ap.reset (SystemRuntime::FindPlugin(this));
2823 return m_system_runtime_ap.get();
2824}
2825
Greg Claytonc3776bf2012-02-09 06:16:32 +00002826
Jim Inghambb3a2832011-01-29 01:49:25 +00002827Process::NextEventAction::EventActionResult
2828Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002829{
Jim Inghambb3a2832011-01-29 01:49:25 +00002830 StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
2831 switch (state)
Greg Clayton19388cf2010-10-18 01:45:30 +00002832 {
Greg Clayton513c26c2011-01-29 07:10:55 +00002833 case eStateRunning:
Greg Clayton71337622011-02-24 22:24:29 +00002834 case eStateConnected:
Greg Clayton513c26c2011-01-29 07:10:55 +00002835 return eEventActionRetry;
2836
2837 case eStateStopped:
2838 case eStateCrashed:
Greg Claytonc9ed4782011-11-12 02:10:56 +00002839 {
2840 // During attach, prior to sending the eStateStopped event,
Jim Inghamb1e2e842012-04-12 18:49:31 +00002841 // lldb_private::Process subclasses must set the new process ID.
Greg Claytonc9ed4782011-11-12 02:10:56 +00002842 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
Jim Ingham221d51c2013-05-08 00:35:16 +00002843 // We don't want these events to be reported, so go set the ShouldReportStop here:
2844 m_process->GetThreadList().SetShouldReportStop (eVoteNo);
2845
Greg Claytonc9ed4782011-11-12 02:10:56 +00002846 if (m_exec_count > 0)
2847 {
2848 --m_exec_count;
Jim Ingham221d51c2013-05-08 00:35:16 +00002849 RequestResume();
Greg Claytonc9ed4782011-11-12 02:10:56 +00002850 return eEventActionRetry;
2851 }
2852 else
2853 {
2854 m_process->CompleteAttach ();
2855 return eEventActionSuccess;
2856 }
2857 }
Greg Clayton513c26c2011-01-29 07:10:55 +00002858 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00002859
Greg Clayton513c26c2011-01-29 07:10:55 +00002860 default:
2861 case eStateExited:
2862 case eStateInvalid:
Greg Clayton513c26c2011-01-29 07:10:55 +00002863 break;
Jim Inghambb3a2832011-01-29 01:49:25 +00002864 }
Greg Claytonc9ed4782011-11-12 02:10:56 +00002865
2866 m_exit_string.assign ("No valid Process");
2867 return eEventActionExit;
Jim Inghambb3a2832011-01-29 01:49:25 +00002868}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002869
Jim Inghambb3a2832011-01-29 01:49:25 +00002870Process::NextEventAction::EventActionResult
2871Process::AttachCompletionHandler::HandleBeingInterrupted()
2872{
2873 return eEventActionSuccess;
2874}
2875
2876const char *
2877Process::AttachCompletionHandler::GetExitString ()
2878{
2879 return m_exit_string.c_str();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002880}
2881
2882Error
Greg Clayton144f3a92011-11-15 03:53:30 +00002883Process::Attach (ProcessAttachInfo &attach_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002884{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002885 m_abi_sp.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002886 m_process_input_reader.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002887 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002888 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00002889 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002890 m_os_ap.reset();
Jim Ingham5aee1622010-08-09 23:31:02 +00002891
Greg Clayton144f3a92011-11-15 03:53:30 +00002892 lldb::pid_t attach_pid = attach_info.GetProcessID();
Greg Claytone996fd32011-03-08 22:40:15 +00002893 Error error;
Greg Clayton144f3a92011-11-15 03:53:30 +00002894 if (attach_pid == LLDB_INVALID_PROCESS_ID)
Jim Ingham5aee1622010-08-09 23:31:02 +00002895 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002896 char process_name[PATH_MAX];
Jim Ingham4299fdb2011-09-15 01:10:17 +00002897
Greg Clayton144f3a92011-11-15 03:53:30 +00002898 if (attach_info.GetExecutableFile().GetPath (process_name, sizeof(process_name)))
Jim Ingham2ecb7422010-08-17 21:54:19 +00002899 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002900 const bool wait_for_launch = attach_info.GetWaitForLaunch();
2901
2902 if (wait_for_launch)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002903 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002904 error = WillAttachToProcessWithName(process_name, wait_for_launch);
2905 if (error.Success())
2906 {
Ed Maste64fad602013-07-29 20:58:06 +00002907 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00002908 {
2909 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00002910 const bool restarted = false;
2911 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00002912 // Now attach using these arguments.
Jean-Daniel Dupas9c517c02013-12-23 22:32:54 +00002913 error = DoAttachToProcessWithName (process_name, attach_info);
Greg Clayton926cce72012-10-12 16:10:12 +00002914 }
2915 else
2916 {
2917 // This shouldn't happen
2918 error.SetErrorString("failed to acquire process run lock");
2919 }
Greg Claytone24c4ac2011-11-17 04:46:02 +00002920
Greg Clayton144f3a92011-11-15 03:53:30 +00002921 if (error.Fail())
2922 {
2923 if (GetID() != LLDB_INVALID_PROCESS_ID)
2924 {
2925 SetID (LLDB_INVALID_PROCESS_ID);
2926 if (error.AsCString() == NULL)
2927 error.SetErrorString("attach failed");
2928
2929 SetExitStatus(-1, error.AsCString());
2930 }
2931 }
2932 else
2933 {
2934 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
2935 StartPrivateStateThread();
2936 }
2937 return error;
2938 }
Greg Claytone996fd32011-03-08 22:40:15 +00002939 }
Greg Clayton144f3a92011-11-15 03:53:30 +00002940 else
Greg Claytone996fd32011-03-08 22:40:15 +00002941 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002942 ProcessInstanceInfoList process_infos;
2943 PlatformSP platform_sp (m_target.GetPlatform ());
2944
2945 if (platform_sp)
2946 {
2947 ProcessInstanceInfoMatch match_info;
2948 match_info.GetProcessInfo() = attach_info;
2949 match_info.SetNameMatchType (eNameMatchEquals);
2950 platform_sp->FindProcesses (match_info, process_infos);
2951 const uint32_t num_matches = process_infos.GetSize();
2952 if (num_matches == 1)
2953 {
2954 attach_pid = process_infos.GetProcessIDAtIndex(0);
2955 // Fall through and attach using the above process ID
2956 }
2957 else
2958 {
2959 match_info.GetProcessInfo().GetExecutableFile().GetPath (process_name, sizeof(process_name));
2960 if (num_matches > 1)
2961 error.SetErrorStringWithFormat ("more than one process named %s", process_name);
2962 else
2963 error.SetErrorStringWithFormat ("could not find a process named %s", process_name);
2964 }
2965 }
2966 else
2967 {
2968 error.SetErrorString ("invalid platform, can't find processes by name");
2969 return error;
2970 }
Greg Claytone996fd32011-03-08 22:40:15 +00002971 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002972 }
2973 else
Greg Clayton144f3a92011-11-15 03:53:30 +00002974 {
2975 error.SetErrorString ("invalid process name");
Greg Claytone996fd32011-03-08 22:40:15 +00002976 }
2977 }
Greg Clayton144f3a92011-11-15 03:53:30 +00002978
2979 if (attach_pid != LLDB_INVALID_PROCESS_ID)
Greg Claytone996fd32011-03-08 22:40:15 +00002980 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002981 error = WillAttachToProcessWithID(attach_pid);
Greg Claytone996fd32011-03-08 22:40:15 +00002982 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002983 {
Greg Clayton144f3a92011-11-15 03:53:30 +00002984
Ed Maste64fad602013-07-29 20:58:06 +00002985 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00002986 {
2987 // Now attach using these arguments.
2988 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00002989 const bool restarted = false;
2990 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00002991 error = DoAttachToProcessWithID (attach_pid, attach_info);
2992 }
2993 else
2994 {
2995 // This shouldn't happen
2996 error.SetErrorString("failed to acquire process run lock");
2997 }
2998
Greg Clayton144f3a92011-11-15 03:53:30 +00002999 if (error.Success())
3000 {
3001
3002 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3003 StartPrivateStateThread();
3004 }
3005 else
Greg Claytone996fd32011-03-08 22:40:15 +00003006 {
3007 if (GetID() != LLDB_INVALID_PROCESS_ID)
3008 {
3009 SetID (LLDB_INVALID_PROCESS_ID);
3010 const char *error_string = error.AsCString();
3011 if (error_string == NULL)
3012 error_string = "attach failed";
3013
3014 SetExitStatus(-1, error_string);
3015 }
3016 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003017 }
3018 }
3019 return error;
3020}
3021
Greg Clayton93d3c8332011-02-16 04:46:07 +00003022void
3023Process::CompleteAttach ()
3024{
3025 // Let the process subclass figure out at much as it can about the process
3026 // before we go looking for a dynamic loader plug-in.
3027 DidAttach();
3028
Jim Ingham4299fdb2011-09-15 01:10:17 +00003029 // We just attached. If we have a platform, ask it for the process architecture, and if it isn't
3030 // the same as the one we've already set, switch architectures.
3031 PlatformSP platform_sp (m_target.GetPlatform ());
3032 assert (platform_sp.get());
3033 if (platform_sp)
3034 {
Greg Clayton70512312012-05-08 01:45:38 +00003035 const ArchSpec &target_arch = m_target.GetArchitecture();
Greg Clayton1e0c8842013-01-11 20:49:54 +00003036 if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture (target_arch, false, NULL))
Greg Clayton70512312012-05-08 01:45:38 +00003037 {
3038 ArchSpec platform_arch;
3039 platform_sp = platform_sp->GetPlatformForArchitecture (target_arch, &platform_arch);
3040 if (platform_sp)
3041 {
3042 m_target.SetPlatform (platform_sp);
3043 m_target.SetArchitecture(platform_arch);
3044 }
3045 }
3046 else
3047 {
3048 ProcessInstanceInfo process_info;
3049 platform_sp->GetProcessInfo (GetID(), process_info);
3050 const ArchSpec &process_arch = process_info.GetArchitecture();
Sean Callananbf4b7be2012-12-13 22:07:14 +00003051 if (process_arch.IsValid() && !m_target.GetArchitecture().IsExactMatch(process_arch))
Greg Clayton70512312012-05-08 01:45:38 +00003052 m_target.SetArchitecture (process_arch);
3053 }
Jim Ingham4299fdb2011-09-15 01:10:17 +00003054 }
3055
3056 // We have completed the attach, now it is time to find the dynamic loader
Greg Clayton93d3c8332011-02-16 04:46:07 +00003057 // plug-in
Greg Claytonc859e2d2012-02-13 23:10:39 +00003058 DynamicLoader *dyld = GetDynamicLoader ();
3059 if (dyld)
3060 dyld->DidAttach();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003061
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003062 GetJITLoaders().DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003063
Jason Molendaeef51062013-11-05 03:57:19 +00003064 SystemRuntime *system_runtime = GetSystemRuntime ();
3065 if (system_runtime)
3066 system_runtime->DidAttach();
3067
Greg Clayton56d9a1b2011-08-22 02:49:39 +00003068 m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
Greg Clayton93d3c8332011-02-16 04:46:07 +00003069 // Figure out which one is the executable, and set that in our target:
Enrico Granata17598482012-11-08 02:22:02 +00003070 const ModuleList &target_modules = m_target.GetImages();
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003071 Mutex::Locker modules_locker(target_modules.GetMutex());
3072 size_t num_modules = target_modules.GetSize();
3073 ModuleSP new_executable_module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003074
Andy Gibbsa297a972013-06-19 19:04:53 +00003075 for (size_t i = 0; i < num_modules; i++)
Greg Clayton93d3c8332011-02-16 04:46:07 +00003076 {
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003077 ModuleSP module_sp (target_modules.GetModuleAtIndexUnlocked (i));
Greg Clayton8b82f082011-04-12 05:54:46 +00003078 if (module_sp && module_sp->IsExecutable())
Greg Clayton93d3c8332011-02-16 04:46:07 +00003079 {
Greg Claytonaa149cb2011-08-11 02:48:45 +00003080 if (m_target.GetExecutableModulePointer() != module_sp.get())
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003081 new_executable_module_sp = module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003082 break;
3083 }
3084 }
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003085 if (new_executable_module_sp)
3086 m_target.SetExecutableModule (new_executable_module_sp, false);
Greg Clayton93d3c8332011-02-16 04:46:07 +00003087}
3088
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003089Error
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003090Process::ConnectRemote (Stream *strm, const char *remote_url)
Greg Claytonb766a732011-02-04 01:58:07 +00003091{
Greg Claytonb766a732011-02-04 01:58:07 +00003092 m_abi_sp.reset();
3093 m_process_input_reader.reset();
3094
3095 // Find the process and its architecture. Make sure it matches the architecture
3096 // of the current Target, and if not adjust it.
3097
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003098 Error error (DoConnectRemote (strm, remote_url));
Greg Claytonb766a732011-02-04 01:58:07 +00003099 if (error.Success())
3100 {
Greg Clayton71337622011-02-24 22:24:29 +00003101 if (GetID() != LLDB_INVALID_PROCESS_ID)
3102 {
Greg Clayton32e0a752011-03-30 18:16:51 +00003103 EventSP event_sp;
3104 StateType state = WaitForProcessStopPrivate(NULL, event_sp);
3105
3106 if (state == eStateStopped || state == eStateCrashed)
3107 {
3108 // If we attached and actually have a process on the other end, then
3109 // this ended up being the equivalent of an attach.
3110 CompleteAttach ();
3111
3112 // This delays passing the stopped event to listeners till
3113 // CompleteAttach gets a chance to complete...
3114 HandlePrivateEvent (event_sp);
3115
3116 }
Greg Clayton71337622011-02-24 22:24:29 +00003117 }
Greg Clayton32e0a752011-03-30 18:16:51 +00003118
3119 if (PrivateStateThreadIsValid ())
3120 ResumePrivateStateThread ();
3121 else
3122 StartPrivateStateThread ();
Greg Claytonb766a732011-02-04 01:58:07 +00003123 }
3124 return error;
3125}
3126
3127
3128Error
Jim Ingham3b8285d2012-04-19 01:40:33 +00003129Process::PrivateResume ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003130{
Greg Clayton5160ce52013-03-27 23:08:40 +00003131 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_STEP));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003132 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003133 log->Printf("Process::PrivateResume() m_stop_id = %u, public state: %s private state: %s",
Jim Ingham4b536182011-08-09 02:12:22 +00003134 m_mod_id.GetStopID(),
Jim Ingham444586b2011-01-24 06:34:17 +00003135 StateAsCString(m_public_state.GetValue()),
3136 StateAsCString(m_private_state.GetValue()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003137
3138 Error error (WillResume());
3139 // Tell the process it is about to resume before the thread list
3140 if (error.Success())
3141 {
Johnny Chenc4221e42010-12-02 20:53:05 +00003142 // Now let the thread list know we are about to resume so it
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003143 // can let all of our threads know that they are about to be
3144 // resumed. Threads will each be called with
3145 // Thread::WillResume(StateType) where StateType contains the state
3146 // that they are supposed to have when the process is resumed
3147 // (suspended/running/stepping). Threads should also check
3148 // their resume signal in lldb::Thread::GetResumeSignal()
Jim Ingham221d51c2013-05-08 00:35:16 +00003149 // to see if they are supposed to start back up with a signal.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003150 if (m_thread_list.WillResume())
3151 {
Jim Ingham372787f2012-04-07 00:00:41 +00003152 // Last thing, do the PreResumeActions.
3153 if (!RunPreResumeActions())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003154 {
Jim Ingham0161b492013-02-09 01:29:05 +00003155 error.SetErrorStringWithFormat ("Process::PrivateResume PreResumeActions failed, not resuming.");
Jim Ingham372787f2012-04-07 00:00:41 +00003156 }
3157 else
3158 {
3159 m_mod_id.BumpResumeID();
3160 error = DoResume();
3161 if (error.Success())
3162 {
3163 DidResume();
3164 m_thread_list.DidResume();
3165 if (log)
3166 log->Printf ("Process thinks the process has resumed.");
3167 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003168 }
3169 }
3170 else
3171 {
Jim Ingham513c6bb2012-09-01 01:02:41 +00003172 // Somebody wanted to run without running. So generate a continue & a stopped event,
3173 // and let the world handle them.
3174 if (log)
3175 log->Printf ("Process::PrivateResume() asked to simulate a start & stop.");
3176
3177 SetPrivateState(eStateRunning);
3178 SetPrivateState(eStateStopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003179 }
3180 }
Jim Ingham444586b2011-01-24 06:34:17 +00003181 else if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003182 log->Printf ("Process::PrivateResume() got an error \"%s\".", error.AsCString("<unknown error>"));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003183 return error;
3184}
3185
3186Error
Greg Claytonf9b57b92013-05-10 23:48:10 +00003187Process::Halt (bool clear_thread_plans)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003188{
Greg Claytonf9b57b92013-05-10 23:48:10 +00003189 // Don't clear the m_clear_thread_plans_on_stop, only set it to true if
3190 // in case it was already set and some thread plan logic calls halt on its
3191 // own.
3192 m_clear_thread_plans_on_stop |= clear_thread_plans;
3193
Jim Inghamaacc3182012-06-06 00:29:30 +00003194 // First make sure we aren't in the middle of handling an event, or we might restart. This is pretty weak, since
3195 // we could just straightaway get another event. It just narrows the window...
3196 m_currently_handling_event.WaitForValueEqualTo(false);
3197
3198
Jim Inghambb3a2832011-01-29 01:49:25 +00003199 // Pause our private state thread so we can ensure no one else eats
3200 // the stop event out from under us.
Jim Ingham0f16e732011-02-08 05:20:59 +00003201 Listener halt_listener ("lldb.process.halt_listener");
3202 HijackPrivateProcessEvents(&halt_listener);
Greg Clayton3af9ea52010-11-18 05:57:03 +00003203
Jim Inghambb3a2832011-01-29 01:49:25 +00003204 EventSP event_sp;
Greg Clayton513c26c2011-01-29 07:10:55 +00003205 Error error (WillHalt());
Jim Inghambb3a2832011-01-29 01:49:25 +00003206
Greg Clayton513c26c2011-01-29 07:10:55 +00003207 if (error.Success())
Jim Inghambb3a2832011-01-29 01:49:25 +00003208 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003209
Greg Clayton513c26c2011-01-29 07:10:55 +00003210 bool caused_stop = false;
3211
3212 // Ask the process subclass to actually halt our process
3213 error = DoHalt(caused_stop);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003214 if (error.Success())
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003215 {
Greg Clayton513c26c2011-01-29 07:10:55 +00003216 if (m_public_state.GetValue() == eStateAttaching)
3217 {
3218 SetExitStatus(SIGKILL, "Cancelled async attach.");
3219 Destroy ();
3220 }
3221 else
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003222 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003223 // If "caused_stop" is true, then DoHalt stopped the process. If
3224 // "caused_stop" is false, the process was already stopped.
3225 // If the DoHalt caused the process to stop, then we want to catch
3226 // this event and set the interrupted bool to true before we pass
3227 // this along so clients know that the process was interrupted by
3228 // a halt command.
3229 if (caused_stop)
Greg Clayton3af9ea52010-11-18 05:57:03 +00003230 {
Jim Ingham0f16e732011-02-08 05:20:59 +00003231 // Wait for 1 second for the process to stop.
Jim Inghambb3a2832011-01-29 01:49:25 +00003232 TimeValue timeout_time;
3233 timeout_time = TimeValue::Now();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003234 timeout_time.OffsetWithSeconds(10);
Jim Ingham0f16e732011-02-08 05:20:59 +00003235 bool got_event = halt_listener.WaitForEvent (&timeout_time, event_sp);
3236 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00003237
Jim Ingham0f16e732011-02-08 05:20:59 +00003238 if (!got_event || state == eStateInvalid)
Greg Clayton3af9ea52010-11-18 05:57:03 +00003239 {
Jim Inghambb3a2832011-01-29 01:49:25 +00003240 // We timeout out and didn't get a stop event...
Jim Ingham0f16e732011-02-08 05:20:59 +00003241 error.SetErrorStringWithFormat ("Halt timed out. State = %s", StateAsCString(GetState()));
Greg Clayton3af9ea52010-11-18 05:57:03 +00003242 }
3243 else
3244 {
Greg Clayton2637f822011-11-17 01:23:07 +00003245 if (StateIsStoppedState (state, false))
Jim Inghambb3a2832011-01-29 01:49:25 +00003246 {
3247 // We caused the process to interrupt itself, so mark this
3248 // as such in the stop event so clients can tell an interrupted
3249 // process from a natural stop
3250 ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);
3251 }
3252 else
3253 {
Greg Clayton5160ce52013-03-27 23:08:40 +00003254 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Inghambb3a2832011-01-29 01:49:25 +00003255 if (log)
3256 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
3257 error.SetErrorString ("Did not get stopped event after halt.");
3258 }
Greg Clayton3af9ea52010-11-18 05:57:03 +00003259 }
3260 }
Jim Inghambb3a2832011-01-29 01:49:25 +00003261 DidHalt();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003262 }
3263 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003264 }
Jim Inghambb3a2832011-01-29 01:49:25 +00003265 // Resume our private state thread before we post the event (if any)
Jim Ingham0f16e732011-02-08 05:20:59 +00003266 RestorePrivateProcessEvents();
Jim Inghambb3a2832011-01-29 01:49:25 +00003267
3268 // Post any event we might have consumed. If all goes well, we will have
3269 // stopped the process, intercepted the event and set the interrupted
3270 // bool in the event. Post it to the private event queue and that will end up
3271 // correctly setting the state.
3272 if (event_sp)
3273 m_private_state_broadcaster.BroadcastEvent(event_sp);
3274
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003275 return error;
3276}
3277
3278Error
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003279Process::HaltForDestroyOrDetach(lldb::EventSP &exit_event_sp)
3280{
3281 Error error;
3282 if (m_public_state.GetValue() == eStateRunning)
3283 {
3284 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3285 if (log)
3286 log->Printf("Process::Destroy() About to halt.");
3287 error = Halt();
3288 if (error.Success())
3289 {
3290 // Consume the halt event.
3291 TimeValue timeout (TimeValue::Now());
3292 timeout.OffsetWithSeconds(1);
3293 StateType state = WaitForProcessToStop (&timeout, &exit_event_sp);
3294
3295 // If the process exited while we were waiting for it to stop, put the exited event into
3296 // the shared pointer passed in and return. Our caller doesn't need to do anything else, since
3297 // they don't have a process anymore...
3298
3299 if (state == eStateExited || m_private_state.GetValue() == eStateExited)
3300 {
3301 if (log)
3302 log->Printf("Process::HaltForDestroyOrDetach() Process exited while waiting to Halt.");
3303 return error;
3304 }
3305 else
3306 exit_event_sp.reset(); // It is ok to consume any non-exit stop events
3307
3308 if (state != eStateStopped)
3309 {
3310 if (log)
3311 log->Printf("Process::HaltForDestroyOrDetach() Halt failed to stop, state is: %s", StateAsCString(state));
3312 // If we really couldn't stop the process then we should just error out here, but if the
3313 // lower levels just bobbled sending the event and we really are stopped, then continue on.
3314 StateType private_state = m_private_state.GetValue();
3315 if (private_state != eStateStopped)
3316 {
3317 return error;
3318 }
3319 }
3320 }
3321 else
3322 {
3323 if (log)
3324 log->Printf("Process::HaltForDestroyOrDetach() Halt got error: %s", error.AsCString());
3325 }
3326 }
3327 return error;
3328}
3329
3330Error
Jim Inghamacff8952013-05-02 00:27:30 +00003331Process::Detach (bool keep_stopped)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003332{
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003333 EventSP exit_event_sp;
3334 Error error;
3335 m_destroy_in_process = true;
3336
3337 error = WillDetach();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003338
3339 if (error.Success())
3340 {
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003341 if (DetachRequiresHalt())
3342 {
3343 error = HaltForDestroyOrDetach (exit_event_sp);
3344 if (!error.Success())
3345 {
3346 m_destroy_in_process = false;
3347 return error;
3348 }
3349 else if (exit_event_sp)
3350 {
3351 // We shouldn't need to do anything else here. There's no process left to detach from...
3352 StopPrivateStateThread();
3353 m_destroy_in_process = false;
3354 return error;
3355 }
3356 }
3357
Andrew MacPhersonc3826b52014-03-25 19:59:36 +00003358 m_thread_list.DiscardThreadPlans();
3359 DisableAllBreakpointSites();
3360
Jim Inghamacff8952013-05-02 00:27:30 +00003361 error = DoDetach(keep_stopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003362 if (error.Success())
3363 {
3364 DidDetach();
3365 StopPrivateStateThread();
3366 }
Jim Inghamacff8952013-05-02 00:27:30 +00003367 else
3368 {
3369 return error;
3370 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003371 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003372 m_destroy_in_process = false;
3373
3374 // If we exited when we were waiting for a process to stop, then
3375 // forward the event here so we don't lose the event
3376 if (exit_event_sp)
3377 {
3378 // Directly broadcast our exited event because we shut down our
3379 // private state thread above
3380 BroadcastEvent(exit_event_sp);
3381 }
3382
3383 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3384 // the last events through the event system, in which case we might strand the write lock. Unlock
3385 // it here so when we do to tear down the process we don't get an error destroying the lock.
3386
Ed Maste64fad602013-07-29 20:58:06 +00003387 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003388 return error;
3389}
3390
3391Error
3392Process::Destroy ()
3393{
Jim Ingham09437922013-03-01 20:04:25 +00003394
3395 // Tell ourselves we are in the process of destroying the process, so that we don't do any unnecessary work
3396 // that might hinder the destruction. Remember to set this back to false when we are done. That way if the attempt
3397 // failed and the process stays around for some reason it won't be in a confused state.
3398
3399 m_destroy_in_process = true;
3400
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003401 Error error (WillDestroy());
3402 if (error.Success())
3403 {
Greg Clayton85fb1b92012-09-11 02:33:37 +00003404 EventSP exit_event_sp;
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003405 if (DestroyRequiresHalt())
Jim Ingham04e0a222012-05-23 15:46:31 +00003406 {
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003407 error = HaltForDestroyOrDetach(exit_event_sp);
Jim Ingham04e0a222012-05-23 15:46:31 +00003408 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003409
Jim Inghamaacc3182012-06-06 00:29:30 +00003410 if (m_public_state.GetValue() != eStateRunning)
3411 {
3412 // Ditch all thread plans, and remove all our breakpoints: in case we have to restart the target to
3413 // kill it, we don't want it hitting a breakpoint...
3414 // Only do this if we've stopped, however, since if we didn't manage to halt it above, then
3415 // we're not going to have much luck doing this now.
3416 m_thread_list.DiscardThreadPlans();
3417 DisableAllBreakpointSites();
3418 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003419
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003420 error = DoDestroy();
3421 if (error.Success())
3422 {
3423 DidDestroy();
3424 StopPrivateStateThread();
3425 }
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003426 m_stdio_communication.StopReadThread();
3427 m_stdio_communication.Disconnect();
Greg Claytonb4874f12014-02-28 18:22:24 +00003428
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003429 if (m_process_input_reader)
Greg Claytonb4874f12014-02-28 18:22:24 +00003430 {
3431 m_process_input_reader->SetIsDone(true);
3432 m_process_input_reader->Cancel();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003433 m_process_input_reader.reset();
Greg Claytonb4874f12014-02-28 18:22:24 +00003434 }
3435
Greg Clayton85fb1b92012-09-11 02:33:37 +00003436 // If we exited when we were waiting for a process to stop, then
3437 // forward the event here so we don't lose the event
3438 if (exit_event_sp)
3439 {
3440 // Directly broadcast our exited event because we shut down our
3441 // private state thread above
3442 BroadcastEvent(exit_event_sp);
3443 }
3444
Jim Inghamb1e2e842012-04-12 18:49:31 +00003445 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3446 // the last events through the event system, in which case we might strand the write lock. Unlock
3447 // 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 +00003448 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003449 }
Jim Ingham09437922013-03-01 20:04:25 +00003450
3451 m_destroy_in_process = false;
3452
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003453 return error;
3454}
3455
3456Error
3457Process::Signal (int signal)
3458{
3459 Error error (WillSignal());
3460 if (error.Success())
3461 {
3462 error = DoSignal(signal);
3463 if (error.Success())
3464 DidSignal();
3465 }
3466 return error;
3467}
3468
Greg Clayton514487e2011-02-15 21:59:32 +00003469lldb::ByteOrder
3470Process::GetByteOrder () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003471{
Greg Clayton514487e2011-02-15 21:59:32 +00003472 return m_target.GetArchitecture().GetByteOrder();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003473}
3474
3475uint32_t
Greg Clayton514487e2011-02-15 21:59:32 +00003476Process::GetAddressByteSize () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003477{
Greg Clayton514487e2011-02-15 21:59:32 +00003478 return m_target.GetArchitecture().GetAddressByteSize();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003479}
3480
Greg Clayton514487e2011-02-15 21:59:32 +00003481
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003482bool
3483Process::ShouldBroadcastEvent (Event *event_ptr)
3484{
3485 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr);
3486 bool return_value = true;
Greg Clayton5160ce52013-03-27 23:08:40 +00003487 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS | LIBLLDB_LOG_PROCESS));
Jim Ingham0161b492013-02-09 01:29:05 +00003488
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003489 switch (state)
3490 {
Greg Claytonb766a732011-02-04 01:58:07 +00003491 case eStateConnected:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003492 case eStateAttaching:
3493 case eStateLaunching:
3494 case eStateDetached:
3495 case eStateExited:
3496 case eStateUnloaded:
3497 // These events indicate changes in the state of the debugging session, always report them.
3498 return_value = true;
3499 break;
3500 case eStateInvalid:
3501 // We stopped for no apparent reason, don't report it.
3502 return_value = false;
3503 break;
3504 case eStateRunning:
3505 case eStateStepping:
3506 // If we've started the target running, we handle the cases where we
3507 // are already running and where there is a transition from stopped to
3508 // running differently.
3509 // running -> running: Automatically suppress extra running events
3510 // stopped -> running: Report except when there is one or more no votes
3511 // and no yes votes.
3512 SynchronouslyNotifyStateChanged (state);
Jim Ingham1460e4b2014-01-10 23:46:59 +00003513 if (m_force_next_event_delivery)
3514 return_value = true;
3515 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003516 {
Jim Ingham1460e4b2014-01-10 23:46:59 +00003517 switch (m_last_broadcast_state)
3518 {
3519 case eStateRunning:
3520 case eStateStepping:
3521 // We always suppress multiple runnings with no PUBLIC stop in between.
3522 return_value = false;
3523 break;
3524 default:
3525 // TODO: make this work correctly. For now always report
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00003526 // run if we aren't running so we don't miss any running
Jim Ingham1460e4b2014-01-10 23:46:59 +00003527 // events. If I run the lldb/test/thread/a.out file and
3528 // break at main.cpp:58, run and hit the breakpoints on
3529 // multiple threads, then somehow during the stepping over
3530 // of all breakpoints no run gets reported.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003531
Jim Ingham1460e4b2014-01-10 23:46:59 +00003532 // This is a transition from stop to run.
3533 switch (m_thread_list.ShouldReportRun (event_ptr))
3534 {
3535 case eVoteYes:
3536 case eVoteNoOpinion:
3537 return_value = true;
3538 break;
3539 case eVoteNo:
3540 return_value = false;
3541 break;
3542 }
3543 break;
3544 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003545 }
3546 break;
3547 case eStateStopped:
3548 case eStateCrashed:
3549 case eStateSuspended:
3550 {
3551 // We've stopped. First see if we're going to restart the target.
3552 // If we are going to stop, then we always broadcast the event.
3553 // 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 +00003554 // If no thread has an opinion, we don't report it.
Jim Ingham221d51c2013-05-08 00:35:16 +00003555
Jim Inghamcb4ca112012-05-16 01:32:14 +00003556 RefreshStateAfterStop ();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003557 if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003558 {
Greg Clayton3af9ea52010-11-18 05:57:03 +00003559 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003560 log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003561 static_cast<void*>(event_ptr),
Jim Ingham0161b492013-02-09 01:29:05 +00003562 StateAsCString(state));
Jim Ingham35878c42014-04-08 21:33:21 +00003563 // Even though we know we are going to stop, we should let the threads have a look at the stop,
3564 // so they can properly set their state.
3565 m_thread_list.ShouldStop (event_ptr);
Jim Ingham0161b492013-02-09 01:29:05 +00003566 return_value = true;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003567 }
3568 else
3569 {
Jim Ingham221d51c2013-05-08 00:35:16 +00003570 bool was_restarted = ProcessEventData::GetRestartedFromEvent (event_ptr);
3571 bool should_resume = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003572
Jim Ingham0161b492013-02-09 01:29:05 +00003573 // It makes no sense to ask "ShouldStop" if we've already been restarted...
3574 // Asking the thread list is also not likely to go well, since we are running again.
3575 // So in that case just report the event.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003576
Jim Ingham0161b492013-02-09 01:29:05 +00003577 if (!was_restarted)
3578 should_resume = m_thread_list.ShouldStop (event_ptr) == false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003579
Jim Ingham221d51c2013-05-08 00:35:16 +00003580 if (was_restarted || should_resume || m_resume_requested)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003581 {
Jim Ingham0161b492013-02-09 01:29:05 +00003582 Vote stop_vote = m_thread_list.ShouldReportStop (event_ptr);
3583 if (log)
3584 log->Printf ("Process::ShouldBroadcastEvent: should_stop: %i state: %s was_restarted: %i stop_vote: %d.",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003585 should_resume, StateAsCString(state),
3586 was_restarted, stop_vote);
3587
Jim Ingham0161b492013-02-09 01:29:05 +00003588 switch (stop_vote)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003589 {
3590 case eVoteYes:
Jim Ingham0161b492013-02-09 01:29:05 +00003591 return_value = true;
3592 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003593 case eVoteNoOpinion:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003594 case eVoteNo:
3595 return_value = false;
3596 break;
3597 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003598
Jim Inghamcb95f342012-09-05 21:13:56 +00003599 if (!was_restarted)
Jim Ingham0161b492013-02-09 01:29:05 +00003600 {
3601 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003602 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s",
3603 static_cast<void*>(event_ptr),
3604 StateAsCString(state));
Jim Ingham0161b492013-02-09 01:29:05 +00003605 ProcessEventData::SetRestartedInEvent(event_ptr, true);
Jim Inghamcb95f342012-09-05 21:13:56 +00003606 PrivateResume ();
Jim Ingham0161b492013-02-09 01:29:05 +00003607 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003608
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003609 }
3610 else
3611 {
3612 return_value = true;
3613 SynchronouslyNotifyStateChanged (state);
3614 }
3615 }
3616 }
Jim Ingham0161b492013-02-09 01:29:05 +00003617 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003618 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003619
Jim Ingham1460e4b2014-01-10 23:46:59 +00003620 // Forcing the next event delivery is a one shot deal. So reset it here.
3621 m_force_next_event_delivery = false;
3622
Jim Ingham0161b492013-02-09 01:29:05 +00003623 // We do some coalescing of events (for instance two consecutive running events get coalesced.)
3624 // But we only coalesce against events we actually broadcast. So we use m_last_broadcast_state
3625 // to track that. NB - you can't use "m_public_state.GetValue()" for that purpose, as was originally done,
3626 // because the PublicState reflects the last event pulled off the queue, and there may be several
3627 // events stacked up on the queue unserviced. So the PublicState may not reflect the last broadcasted event
3628 // yet. m_last_broadcast_state gets updated here.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003629
Jim Ingham0161b492013-02-09 01:29:05 +00003630 if (return_value)
3631 m_last_broadcast_state = state;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003632
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003633 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003634 log->Printf ("Process::ShouldBroadcastEvent (%p) => new state: %s, last broadcast state: %s - %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003635 static_cast<void*>(event_ptr), StateAsCString(state),
Jim Ingham0161b492013-02-09 01:29:05 +00003636 StateAsCString(m_last_broadcast_state),
3637 return_value ? "YES" : "NO");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003638 return return_value;
3639}
3640
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003641
3642bool
Jim Ingham372787f2012-04-07 00:00:41 +00003643Process::StartPrivateStateThread (bool force)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003644{
Greg Clayton5160ce52013-03-27 23:08:40 +00003645 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003646
Greg Clayton8b82f082011-04-12 05:54:46 +00003647 bool already_running = PrivateStateThreadIsValid ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003648 if (log)
Greg Clayton8b82f082011-04-12 05:54:46 +00003649 log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread");
3650
Jim Ingham372787f2012-04-07 00:00:41 +00003651 if (!force && already_running)
Greg Clayton8b82f082011-04-12 05:54:46 +00003652 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003653
3654 // Create a thread that watches our internal state and controls which
3655 // events make it to clients (into the DCProcess event queue).
Greg Clayton3e06bd92011-01-09 21:07:35 +00003656 char thread_name[1024];
Jim Ingham372787f2012-04-07 00:00:41 +00003657 if (already_running)
Daniel Malead01b2952012-11-29 21:49:15 +00003658 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state-override(pid=%" PRIu64 ")>", GetID());
Jim Ingham372787f2012-04-07 00:00:41 +00003659 else
Daniel Malead01b2952012-11-29 21:49:15 +00003660 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
Jim Ingham076b3042012-04-10 01:21:57 +00003661
3662 // Create the private state thread, and start it running.
Greg Clayton3e06bd92011-01-09 21:07:35 +00003663 m_private_state_thread = Host::ThreadCreate (thread_name, Process::PrivateStateThread, this, NULL);
Jim Ingham076b3042012-04-10 01:21:57 +00003664 bool success = IS_VALID_LLDB_HOST_THREAD(m_private_state_thread);
3665 if (success)
3666 {
3667 ResumePrivateStateThread();
3668 return true;
3669 }
3670 else
3671 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003672}
3673
3674void
3675Process::PausePrivateStateThread ()
3676{
3677 ControlPrivateStateThread (eBroadcastInternalStateControlPause);
3678}
3679
3680void
3681Process::ResumePrivateStateThread ()
3682{
3683 ControlPrivateStateThread (eBroadcastInternalStateControlResume);
3684}
3685
3686void
3687Process::StopPrivateStateThread ()
3688{
Greg Clayton8b82f082011-04-12 05:54:46 +00003689 if (PrivateStateThreadIsValid ())
3690 ControlPrivateStateThread (eBroadcastInternalStateControlStop);
Jim Inghamb1e2e842012-04-12 18:49:31 +00003691 else
3692 {
Greg Clayton5160ce52013-03-27 23:08:40 +00003693 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Jim Inghamb1e2e842012-04-12 18:49:31 +00003694 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003695 log->Printf ("Went to stop the private state thread, but it was already invalid.");
Jim Inghamb1e2e842012-04-12 18:49:31 +00003696 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003697}
3698
3699void
3700Process::ControlPrivateStateThread (uint32_t signal)
3701{
Greg Clayton5160ce52013-03-27 23:08:40 +00003702 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003703
3704 assert (signal == eBroadcastInternalStateControlStop ||
3705 signal == eBroadcastInternalStateControlPause ||
3706 signal == eBroadcastInternalStateControlResume);
3707
3708 if (log)
Greg Clayton7ecb3a02011-01-22 17:43:17 +00003709 log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003710
Greg Clayton7ecb3a02011-01-22 17:43:17 +00003711 // Signal the private state thread. First we should copy this is case the
3712 // thread starts exiting since the private state thread will NULL this out
3713 // when it exits
3714 const lldb::thread_t private_state_thread = m_private_state_thread;
Greg Clayton2da6d492011-02-08 01:34:25 +00003715 if (IS_VALID_LLDB_HOST_THREAD(private_state_thread))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003716 {
3717 TimeValue timeout_time;
3718 bool timed_out;
3719
3720 m_private_state_control_broadcaster.BroadcastEvent (signal, NULL);
3721
3722 timeout_time = TimeValue::Now();
3723 timeout_time.OffsetWithSeconds(2);
Jim Inghamb1e2e842012-04-12 18:49:31 +00003724 if (log)
3725 log->Printf ("Sending control event of type: %d.", signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003726 m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out);
3727 m_private_state_control_wait.SetValue (false, eBroadcastNever);
3728
3729 if (signal == eBroadcastInternalStateControlStop)
3730 {
3731 if (timed_out)
Jim Inghamb1e2e842012-04-12 18:49:31 +00003732 {
3733 Error error;
3734 Host::ThreadCancel (private_state_thread, &error);
3735 if (log)
3736 log->Printf ("Timed out responding to the control event, cancel got error: \"%s\".", error.AsCString());
3737 }
3738 else
3739 {
3740 if (log)
3741 log->Printf ("The control event killed the private state thread without having to cancel.");
3742 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003743
3744 thread_result_t result = NULL;
Greg Clayton7ecb3a02011-01-22 17:43:17 +00003745 Host::ThreadJoin (private_state_thread, &result, NULL);
Greg Clayton49182ed2010-07-22 18:34:21 +00003746 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003747 }
3748 }
Jim Inghamb1e2e842012-04-12 18:49:31 +00003749 else
3750 {
3751 if (log)
3752 log->Printf ("Private state thread already dead, no need to signal it to stop.");
3753 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003754}
3755
3756void
Jim Inghamcfc09352012-07-27 23:57:19 +00003757Process::SendAsyncInterrupt ()
3758{
3759 if (PrivateStateThreadIsValid())
3760 m_private_state_broadcaster.BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
3761 else
3762 BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
3763}
3764
3765void
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003766Process::HandlePrivateEvent (EventSP &event_sp)
3767{
Greg Clayton5160ce52013-03-27 23:08:40 +00003768 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Ingham221d51c2013-05-08 00:35:16 +00003769 m_resume_requested = false;
3770
Jim Inghamaacc3182012-06-06 00:29:30 +00003771 m_currently_handling_event.SetValue(true, eBroadcastNever);
Jim Inghambb3a2832011-01-29 01:49:25 +00003772
Greg Clayton414f5d32011-01-25 02:58:48 +00003773 const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00003774
3775 // First check to see if anybody wants a shot at this event:
Jim Ingham754ab982011-01-29 04:05:41 +00003776 if (m_next_event_action_ap.get() != NULL)
Jim Inghambb3a2832011-01-29 01:49:25 +00003777 {
Jim Ingham754ab982011-01-29 04:05:41 +00003778 NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp);
Jim Ingham0161b492013-02-09 01:29:05 +00003779 if (log)
3780 log->Printf ("Ran next event action, result was %d.", action_result);
3781
Jim Inghambb3a2832011-01-29 01:49:25 +00003782 switch (action_result)
3783 {
3784 case NextEventAction::eEventActionSuccess:
3785 SetNextEventAction(NULL);
3786 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00003787
Jim Inghambb3a2832011-01-29 01:49:25 +00003788 case NextEventAction::eEventActionRetry:
3789 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00003790
Jim Inghambb3a2832011-01-29 01:49:25 +00003791 case NextEventAction::eEventActionExit:
Jim Ingham2a5fdd42011-01-29 01:57:31 +00003792 // Handle Exiting Here. If we already got an exited event,
3793 // we should just propagate it. Otherwise, swallow this event,
3794 // and set our state to exit so the next event will kill us.
3795 if (new_state != eStateExited)
3796 {
3797 // FIXME: should cons up an exited event, and discard this one.
Jim Ingham754ab982011-01-29 04:05:41 +00003798 SetExitStatus(0, m_next_event_action_ap->GetExitString());
Jim Ingham221d51c2013-05-08 00:35:16 +00003799 m_currently_handling_event.SetValue(false, eBroadcastAlways);
Jim Ingham2a5fdd42011-01-29 01:57:31 +00003800 SetNextEventAction(NULL);
3801 return;
3802 }
3803 SetNextEventAction(NULL);
Jim Inghambb3a2832011-01-29 01:49:25 +00003804 break;
3805 }
3806 }
3807
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003808 // See if we should broadcast this state to external clients?
3809 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003810
3811 if (should_broadcast)
3812 {
Greg Claytonb4874f12014-02-28 18:22:24 +00003813 const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003814 if (log)
3815 {
Daniel Malead01b2952012-11-29 21:49:15 +00003816 log->Printf ("Process::%s (pid = %" PRIu64 ") broadcasting new state %s (old state %s) to %s",
Greg Clayton414f5d32011-01-25 02:58:48 +00003817 __FUNCTION__,
3818 GetID(),
3819 StateAsCString(new_state),
3820 StateAsCString (GetState ()),
Greg Claytonb4874f12014-02-28 18:22:24 +00003821 is_hijacked ? "hijacked" : "public");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003822 }
Jim Ingham9575d842011-03-11 03:53:59 +00003823 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
Greg Clayton414f5d32011-01-25 02:58:48 +00003824 if (StateIsRunningState (new_state))
Greg Clayton44d93782014-01-27 23:43:24 +00003825 {
3826 // Only push the input handler if we aren't fowarding events,
3827 // as this means the curses GUI is in use...
3828 if (!GetTarget().GetDebugger().IsForwardingEvents())
3829 PushProcessIOHandler ();
3830 }
Greg Claytonb4874f12014-02-28 18:22:24 +00003831 else if (StateIsStoppedState(new_state, false))
3832 {
3833 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
3834 {
3835 // If the lldb_private::Debugger is handling the events, we don't
3836 // want to pop the process IOHandler here, we want to do it when
3837 // we receive the stopped event so we can carefully control when
3838 // the process IOHandler is popped because when we stop we want to
3839 // display some text stating how and why we stopped, then maybe some
3840 // process/thread/frame info, and then we want the "(lldb) " prompt
3841 // to show up. If we pop the process IOHandler here, then we will
3842 // cause the command interpreter to become the top IOHandler after
3843 // the process pops off and it will update its prompt right away...
3844 // See the Debugger.cpp file where it calls the function as
3845 // "process_sp->PopProcessIOHandler()" to see where I am talking about.
3846 // Otherwise we end up getting overlapping "(lldb) " prompts and
3847 // garbled output.
3848 //
3849 // If we aren't handling the events in the debugger (which is indicated
3850 // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or we
3851 // are hijacked, then we always pop the process IO handler manually.
3852 // Hijacking happens when the internal process state thread is running
3853 // thread plans, or when commands want to run in synchronous mode
3854 // and they call "process->WaitForProcessToStop()". An example of something
3855 // that will hijack the events is a simple expression:
3856 //
3857 // (lldb) expr (int)puts("hello")
3858 //
3859 // This will cause the internal process state thread to resume and halt
3860 // the process (and _it_ will hijack the eBroadcastBitStateChanged
3861 // events) and we do need the IO handler to be pushed and popped
3862 // correctly.
3863
3864 if (is_hijacked || m_target.GetDebugger().IsHandlingEvents() == false)
3865 PopProcessIOHandler ();
3866 }
3867 }
Jim Ingham9575d842011-03-11 03:53:59 +00003868
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003869 BroadcastEvent (event_sp);
3870 }
3871 else
3872 {
3873 if (log)
3874 {
Daniel Malead01b2952012-11-29 21:49:15 +00003875 log->Printf ("Process::%s (pid = %" PRIu64 ") suppressing state %s (old state %s): should_broadcast == false",
Greg Clayton414f5d32011-01-25 02:58:48 +00003876 __FUNCTION__,
3877 GetID(),
3878 StateAsCString(new_state),
Jason Molendafd54b362011-09-20 21:44:10 +00003879 StateAsCString (GetState ()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003880 }
3881 }
Jim Inghamaacc3182012-06-06 00:29:30 +00003882 m_currently_handling_event.SetValue(false, eBroadcastAlways);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003883}
3884
Virgile Bellob2f1fb22013-08-23 12:44:05 +00003885thread_result_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003886Process::PrivateStateThread (void *arg)
3887{
3888 Process *proc = static_cast<Process*> (arg);
Virgile Bellob2f1fb22013-08-23 12:44:05 +00003889 thread_result_t result = proc->RunPrivateStateThread();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003890 return result;
3891}
3892
Virgile Bellob2f1fb22013-08-23 12:44:05 +00003893thread_result_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003894Process::RunPrivateStateThread ()
3895{
Jim Ingham076b3042012-04-10 01:21:57 +00003896 bool control_only = true;
Jim Inghamb1e2e842012-04-12 18:49:31 +00003897 m_private_state_control_wait.SetValue (false, eBroadcastNever);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003898
Greg Clayton5160ce52013-03-27 23:08:40 +00003899 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003900 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003901 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
3902 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003903
3904 bool exit_now = false;
3905 while (!exit_now)
3906 {
3907 EventSP event_sp;
3908 WaitForEventsPrivate (NULL, event_sp, control_only);
3909 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
3910 {
Jim Inghamb1e2e842012-04-12 18:49:31 +00003911 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003912 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") got a control event: %d",
3913 __FUNCTION__, static_cast<void*>(this), GetID(),
3914 event_sp->GetType());
Jim Inghamb1e2e842012-04-12 18:49:31 +00003915
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003916 switch (event_sp->GetType())
3917 {
3918 case eBroadcastInternalStateControlStop:
3919 exit_now = true;
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00003920 break; // doing any internal state management below
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003921
3922 case eBroadcastInternalStateControlPause:
3923 control_only = true;
3924 break;
3925
3926 case eBroadcastInternalStateControlResume:
3927 control_only = false;
3928 break;
3929 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003930
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003931 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003932 continue;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003933 }
Jim Inghamcfc09352012-07-27 23:57:19 +00003934 else if (event_sp->GetType() == eBroadcastBitInterrupt)
3935 {
3936 if (m_public_state.GetValue() == eStateAttaching)
3937 {
3938 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003939 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt while attaching - forwarding interrupt.",
3940 __FUNCTION__, static_cast<void*>(this),
3941 GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00003942 BroadcastEvent (eBroadcastBitInterrupt, NULL);
3943 }
3944 else
3945 {
3946 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003947 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt - Halting.",
3948 __FUNCTION__, static_cast<void*>(this),
3949 GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00003950 Halt();
3951 }
3952 continue;
3953 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003954
3955 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
3956
3957 if (internal_state != eStateInvalid)
3958 {
Greg Claytonf9b57b92013-05-10 23:48:10 +00003959 if (m_clear_thread_plans_on_stop &&
3960 StateIsStoppedState(internal_state, true))
3961 {
3962 m_clear_thread_plans_on_stop = false;
3963 m_thread_list.DiscardThreadPlans();
3964 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003965 HandlePrivateEvent (event_sp);
3966 }
3967
Greg Clayton58d1c9a2010-10-18 04:14:23 +00003968 if (internal_state == eStateInvalid ||
3969 internal_state == eStateExited ||
3970 internal_state == eStateDetached )
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003971 {
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003972 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003973 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") about to exit with internal state %s...",
3974 __FUNCTION__, static_cast<void*>(this), GetID(),
3975 StateAsCString(internal_state));
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003976
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003977 break;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003978 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003979 }
3980
Caroline Tice20ad3c42010-10-29 21:48:37 +00003981 // Verify log is still enabled before attempting to write to it...
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003982 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003983 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
3984 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003985
Ed Maste64fad602013-07-29 20:58:06 +00003986 m_public_run_lock.SetStopped();
Greg Clayton6ed95942011-01-22 07:12:45 +00003987 m_private_state_control_wait.SetValue (true, eBroadcastAlways);
3988 m_private_state_thread = LLDB_INVALID_HOST_THREAD;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003989 return NULL;
3990}
3991
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003992//------------------------------------------------------------------
3993// Process Event Data
3994//------------------------------------------------------------------
3995
3996Process::ProcessEventData::ProcessEventData () :
3997 EventData (),
3998 m_process_sp (),
3999 m_state (eStateInvalid),
Greg Claytonc982c762010-07-09 20:39:50 +00004000 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004001 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004002 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004003{
4004}
4005
4006Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) :
4007 EventData (),
4008 m_process_sp (process_sp),
4009 m_state (state),
Greg Claytonc982c762010-07-09 20:39:50 +00004010 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004011 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004012 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004013{
4014}
4015
4016Process::ProcessEventData::~ProcessEventData()
4017{
4018}
4019
4020const ConstString &
4021Process::ProcessEventData::GetFlavorString ()
4022{
4023 static ConstString g_flavor ("Process::ProcessEventData");
4024 return g_flavor;
4025}
4026
4027const ConstString &
4028Process::ProcessEventData::GetFlavor () const
4029{
4030 return ProcessEventData::GetFlavorString ();
4031}
4032
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004033void
4034Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
4035{
4036 // This function gets called twice for each event, once when the event gets pulled
Jim Inghama8604692011-05-22 21:45:01 +00004037 // off of the private process event queue, and then any number of times, first when it gets pulled off of
4038 // the public event queue, then other times when we're pretending that this is where we stopped at the
4039 // end of expression evaluation. m_update_state is used to distinguish these
4040 // three cases; it is 0 when we're just pulling it off for private handling,
Jim Ingham221d51c2013-05-08 00:35:16 +00004041 // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
Jim Inghama8604692011-05-22 21:45:01 +00004042 if (m_update_state != 1)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004043 return;
Jim Ingham0161b492013-02-09 01:29:05 +00004044
Jim Ingham221d51c2013-05-08 00:35:16 +00004045 m_process_sp->SetPublicState (m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
Jim Ingham35878c42014-04-08 21:33:21 +00004046
4047 // If this is a halt event, even if the halt stopped with some reason other than a plain interrupt (e.g. we had
4048 // already stopped for a breakpoint when the halt request came through) don't do the StopInfo actions, as they may
4049 // end up restarting the process.
4050 if (m_interrupted)
4051 return;
4052
4053 // If we're stopped and haven't restarted, then do the StopInfo actions here:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004054 if (m_state == eStateStopped && ! m_restarted)
Jim Ingham0faa43f2011-11-08 03:00:11 +00004055 {
4056 ThreadList &curr_thread_list = m_process_sp->GetThreadList();
Greg Clayton61e7a582011-12-01 23:28:38 +00004057 uint32_t num_threads = curr_thread_list.GetSize();
4058 uint32_t idx;
Greg Claytonf4b47e12010-08-04 01:40:35 +00004059
Jim Ingham4b536182011-08-09 02:12:22 +00004060 // The actions might change one of the thread's stop_info's opinions about whether we should
4061 // stop the process, so we need to query that as we go.
Jim Ingham0faa43f2011-11-08 03:00:11 +00004062
4063 // One other complication here, is that we try to catch any case where the target has run (except for expressions)
4064 // and immediately exit, but if we get that wrong (which is possible) then the thread list might have changed, and
4065 // that would cause our iteration here to crash. We could make a copy of the thread list, but we'd really like
4066 // 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
4067 // against this list & bag out if anything differs.
Greg Clayton61e7a582011-12-01 23:28:38 +00004068 std::vector<uint32_t> thread_index_array(num_threads);
Jim Ingham0faa43f2011-11-08 03:00:11 +00004069 for (idx = 0; idx < num_threads; ++idx)
4070 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
4071
Jim Inghamc7078c22012-12-13 22:24:15 +00004072 // Use this to track whether we should continue from here. We will only continue the target running if
4073 // no thread says we should stop. Of course if some thread's PerformAction actually sets the target running,
4074 // then it doesn't matter what the other threads say...
4075
4076 bool still_should_stop = false;
Jim Ingham4b536182011-08-09 02:12:22 +00004077
Jim Ingham0ad7e052013-04-25 02:04:59 +00004078 // Sometimes - for instance if we have a bug in the stub we are talking to, we stop but no thread has a
4079 // valid stop reason. In that case we should just stop, because we have no way of telling what the right
4080 // thing to do is, and it's better to let the user decide than continue behind their backs.
4081
4082 bool does_anybody_have_an_opinion = false;
4083
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004084 for (idx = 0; idx < num_threads; ++idx)
4085 {
Jim Ingham0faa43f2011-11-08 03:00:11 +00004086 curr_thread_list = m_process_sp->GetThreadList();
4087 if (curr_thread_list.GetSize() != num_threads)
4088 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004089 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004090 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004091 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 +00004092 break;
4093 }
4094
4095 lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
4096
4097 if (thread_sp->GetIndexID() != thread_index_array[idx])
4098 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004099 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004100 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004101 log->Printf("The thread at position %u changed from %u to %u while processing event.",
Jim Ingham87c665f2011-12-01 20:26:15 +00004102 idx,
4103 thread_index_array[idx],
4104 thread_sp->GetIndexID());
Jim Ingham0faa43f2011-11-08 03:00:11 +00004105 break;
4106 }
4107
Jim Inghamb15bfc72010-10-20 00:39:53 +00004108 StopInfoSP stop_info_sp = thread_sp->GetStopInfo ();
Jim Ingham5d88a062012-10-16 00:09:33 +00004109 if (stop_info_sp && stop_info_sp->IsValid())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004110 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004111 does_anybody_have_an_opinion = true;
Jim Ingham0161b492013-02-09 01:29:05 +00004112 bool this_thread_wants_to_stop;
4113 if (stop_info_sp->GetOverrideShouldStop())
Jim Ingham4b536182011-08-09 02:12:22 +00004114 {
Jim Ingham0161b492013-02-09 01:29:05 +00004115 this_thread_wants_to_stop = stop_info_sp->GetOverriddenShouldStopValue();
4116 }
4117 else
4118 {
4119 stop_info_sp->PerformAction(event_ptr);
4120 // The stop action might restart the target. If it does, then we want to mark that in the
4121 // event so that whoever is receiving it will know to wait for the running event and reflect
4122 // that state appropriately.
4123 // We also need to stop processing actions, since they aren't expecting the target to be running.
4124
4125 // FIXME: we might have run.
4126 if (stop_info_sp->HasTargetRunSinceMe())
4127 {
4128 SetRestarted (true);
4129 break;
4130 }
4131
4132 this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
Jim Ingham4b536182011-08-09 02:12:22 +00004133 }
Jim Inghamc7078c22012-12-13 22:24:15 +00004134
Jim Inghamc7078c22012-12-13 22:24:15 +00004135 if (still_should_stop == false)
4136 still_should_stop = this_thread_wants_to_stop;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004137 }
4138 }
Jim Ingham3ebcf7f2010-08-10 00:59:59 +00004139
Ashok Thirumurthicf7c55e2013-04-18 14:38:20 +00004140
Jim Inghama8ca6e22013-05-03 23:04:37 +00004141 if (!GetRestarted())
Jim Ingham9575d842011-03-11 03:53:59 +00004142 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004143 if (!still_should_stop && does_anybody_have_an_opinion)
Jim Ingham4b536182011-08-09 02:12:22 +00004144 {
4145 // We've been asked to continue, so do that here.
Jim Ingham9575d842011-03-11 03:53:59 +00004146 SetRestarted(true);
Jim Ingham3b8285d2012-04-19 01:40:33 +00004147 // Use the public resume method here, since this is just
4148 // extending a public resume.
Jim Ingham0161b492013-02-09 01:29:05 +00004149 m_process_sp->PrivateResume();
Jim Ingham4b536182011-08-09 02:12:22 +00004150 }
4151 else
4152 {
4153 // If we didn't restart, run the Stop Hooks here:
4154 // They might also restart the target, so watch for that.
4155 m_process_sp->GetTarget().RunStopHooks();
4156 if (m_process_sp->GetPrivateState() == eStateRunning)
4157 SetRestarted(true);
4158 }
Jim Ingham9575d842011-03-11 03:53:59 +00004159 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004160 }
4161}
4162
4163void
4164Process::ProcessEventData::Dump (Stream *s) const
4165{
4166 if (m_process_sp)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004167 s->Printf(" process = %p (pid = %" PRIu64 "), ",
4168 static_cast<void*>(m_process_sp.get()), m_process_sp->GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004169
Greg Clayton8b82f082011-04-12 05:54:46 +00004170 s->Printf("state = %s", StateAsCString(GetState()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004171}
4172
4173const Process::ProcessEventData *
4174Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr)
4175{
4176 if (event_ptr)
4177 {
4178 const EventData *event_data = event_ptr->GetData();
4179 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString())
4180 return static_cast <const ProcessEventData *> (event_ptr->GetData());
4181 }
4182 return NULL;
4183}
4184
4185ProcessSP
4186Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr)
4187{
4188 ProcessSP process_sp;
4189 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4190 if (data)
4191 process_sp = data->GetProcessSP();
4192 return process_sp;
4193}
4194
4195StateType
4196Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr)
4197{
4198 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4199 if (data == NULL)
4200 return eStateInvalid;
4201 else
4202 return data->GetState();
4203}
4204
4205bool
4206Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr)
4207{
4208 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4209 if (data == NULL)
4210 return false;
4211 else
4212 return data->GetRestarted();
4213}
4214
4215void
4216Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value)
4217{
4218 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4219 if (data != NULL)
4220 data->SetRestarted(new_value);
4221}
4222
Jim Ingham0161b492013-02-09 01:29:05 +00004223size_t
4224Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr)
4225{
4226 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4227 if (data != NULL)
4228 return data->GetNumRestartedReasons();
4229 else
4230 return 0;
4231}
4232
4233const char *
4234Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr, size_t idx)
4235{
4236 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4237 if (data != NULL)
4238 return data->GetRestartedReasonAtIndex(idx);
4239 else
4240 return NULL;
4241}
4242
4243void
4244Process::ProcessEventData::AddRestartedReason (Event *event_ptr, const char *reason)
4245{
4246 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4247 if (data != NULL)
4248 data->AddRestartedReason(reason);
4249}
4250
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004251bool
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004252Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr)
4253{
4254 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4255 if (data == NULL)
4256 return false;
4257 else
4258 return data->GetInterrupted ();
4259}
4260
4261void
4262Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value)
4263{
4264 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4265 if (data != NULL)
4266 data->SetInterrupted(new_value);
4267}
4268
4269bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004270Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr)
4271{
4272 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4273 if (data)
4274 {
4275 data->SetUpdateStateOnRemoval();
4276 return true;
4277 }
4278 return false;
4279}
4280
Greg Claytond9e416c2012-02-18 05:35:26 +00004281lldb::TargetSP
4282Process::CalculateTarget ()
4283{
4284 return m_target.shared_from_this();
4285}
4286
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004287void
Greg Clayton0603aa92010-10-04 01:05:56 +00004288Process::CalculateExecutionContext (ExecutionContext &exe_ctx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004289{
Greg Claytonc14ee322011-09-22 04:58:26 +00004290 exe_ctx.SetTargetPtr (&m_target);
4291 exe_ctx.SetProcessPtr (this);
4292 exe_ctx.SetThreadPtr(NULL);
4293 exe_ctx.SetFramePtr (NULL);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004294}
4295
Greg Claytone996fd32011-03-08 22:40:15 +00004296//uint32_t
4297//Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
4298//{
4299// return 0;
4300//}
4301//
4302//ArchSpec
4303//Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4304//{
4305// return Host::GetArchSpecForExistingProcess (pid);
4306//}
4307//
4308//ArchSpec
4309//Process::GetArchSpecForExistingProcess (const char *process_name)
4310//{
4311// return Host::GetArchSpecForExistingProcess (process_name);
4312//}
4313//
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004314void
4315Process::AppendSTDOUT (const char * s, size_t len)
4316{
Greg Clayton3af9ea52010-11-18 05:57:03 +00004317 Mutex::Locker locker (m_stdio_communication_mutex);
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004318 m_stdout_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004319 BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (shared_from_this(), GetState()));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004320}
4321
4322void
Greg Clayton93e86192011-11-13 04:45:22 +00004323Process::AppendSTDERR (const char * s, size_t len)
4324{
4325 Mutex::Locker locker (m_stdio_communication_mutex);
4326 m_stderr_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004327 BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (shared_from_this(), GetState()));
Greg Clayton93e86192011-11-13 04:45:22 +00004328}
4329
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004330void
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004331Process::BroadcastAsyncProfileData(const std::string &one_profile_data)
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004332{
4333 Mutex::Locker locker (m_profile_data_comm_mutex);
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004334 m_profile_data.push_back(one_profile_data);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004335 BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState()));
4336}
4337
4338size_t
4339Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
4340{
4341 Mutex::Locker locker(m_profile_data_comm_mutex);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004342 if (m_profile_data.empty())
4343 return 0;
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004344
4345 std::string &one_profile_data = m_profile_data.front();
4346 size_t bytes_available = one_profile_data.size();
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004347 if (bytes_available > 0)
4348 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004349 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004350 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004351 log->Printf ("Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4352 static_cast<void*>(buf),
4353 static_cast<uint64_t>(buf_size));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004354 if (bytes_available > buf_size)
4355 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004356 memcpy(buf, one_profile_data.c_str(), buf_size);
4357 one_profile_data.erase(0, buf_size);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004358 bytes_available = buf_size;
4359 }
4360 else
4361 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004362 memcpy(buf, one_profile_data.c_str(), bytes_available);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004363 m_profile_data.erase(m_profile_data.begin());
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004364 }
4365 }
4366 return bytes_available;
4367}
4368
4369
Greg Clayton93e86192011-11-13 04:45:22 +00004370//------------------------------------------------------------------
4371// Process STDIO
4372//------------------------------------------------------------------
4373
4374size_t
4375Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
4376{
4377 Mutex::Locker locker(m_stdio_communication_mutex);
4378 size_t bytes_available = m_stdout_data.size();
4379 if (bytes_available > 0)
4380 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004381 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004382 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004383 log->Printf ("Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4384 static_cast<void*>(buf),
4385 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004386 if (bytes_available > buf_size)
4387 {
4388 memcpy(buf, m_stdout_data.c_str(), buf_size);
4389 m_stdout_data.erase(0, buf_size);
4390 bytes_available = buf_size;
4391 }
4392 else
4393 {
4394 memcpy(buf, m_stdout_data.c_str(), bytes_available);
4395 m_stdout_data.clear();
4396 }
4397 }
4398 return bytes_available;
4399}
4400
4401
4402size_t
4403Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
4404{
4405 Mutex::Locker locker(m_stdio_communication_mutex);
4406 size_t bytes_available = m_stderr_data.size();
4407 if (bytes_available > 0)
4408 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004409 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004410 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004411 log->Printf ("Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4412 static_cast<void*>(buf),
4413 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004414 if (bytes_available > buf_size)
4415 {
4416 memcpy(buf, m_stderr_data.c_str(), buf_size);
4417 m_stderr_data.erase(0, buf_size);
4418 bytes_available = buf_size;
4419 }
4420 else
4421 {
4422 memcpy(buf, m_stderr_data.c_str(), bytes_available);
4423 m_stderr_data.clear();
4424 }
4425 }
4426 return bytes_available;
4427}
4428
4429void
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004430Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
4431{
4432 Process *process = (Process *) baton;
4433 process->AppendSTDOUT (static_cast<const char *>(src), src_len);
4434}
4435
Greg Clayton44d93782014-01-27 23:43:24 +00004436class IOHandlerProcessSTDIO :
4437 public IOHandler
4438{
4439public:
4440 IOHandlerProcessSTDIO (Process *process,
4441 int write_fd) :
4442 IOHandler(process->GetTarget().GetDebugger()),
4443 m_process (process),
4444 m_read_file (),
4445 m_write_file (write_fd, false),
Greg Clayton100eb932014-07-02 21:10:39 +00004446 m_pipe ()
Greg Clayton44d93782014-01-27 23:43:24 +00004447 {
4448 m_read_file.SetDescriptor(GetInputFD(), false);
4449 }
4450
4451 virtual
4452 ~IOHandlerProcessSTDIO ()
4453 {
4454
4455 }
4456
4457 bool
4458 OpenPipes ()
4459 {
Greg Clayton100eb932014-07-02 21:10:39 +00004460 if (m_pipe.IsValid())
Greg Clayton44d93782014-01-27 23:43:24 +00004461 return true;
Greg Clayton100eb932014-07-02 21:10:39 +00004462 return m_pipe.Open();
Greg Clayton44d93782014-01-27 23:43:24 +00004463 }
4464
4465 void
4466 ClosePipes()
4467 {
Greg Clayton100eb932014-07-02 21:10:39 +00004468 m_pipe.Close();
Greg Clayton44d93782014-01-27 23:43:24 +00004469 }
4470
4471 // Each IOHandler gets to run until it is done. It should read data
4472 // from the "in" and place output into "out" and "err and return
4473 // when done.
4474 virtual void
4475 Run ()
4476 {
4477 if (m_read_file.IsValid() && m_write_file.IsValid())
4478 {
4479 SetIsDone(false);
4480 if (OpenPipes())
4481 {
4482 const int read_fd = m_read_file.GetDescriptor();
Greg Clayton100eb932014-07-02 21:10:39 +00004483 const int pipe_read_fd = m_pipe.GetReadFileDescriptor();
Greg Clayton44d93782014-01-27 23:43:24 +00004484 TerminalState terminal_state;
4485 terminal_state.Save (read_fd, false);
4486 Terminal terminal(read_fd);
4487 terminal.SetCanonical(false);
4488 terminal.SetEcho(false);
Deepak Panickal914b8d92014-01-31 18:48:46 +00004489// FD_ZERO, FD_SET are not supported on windows
Hafiz Abid Qadeer6eff1012014-03-12 10:45:23 +00004490#ifndef _WIN32
Greg Clayton44d93782014-01-27 23:43:24 +00004491 while (!GetIsDone())
4492 {
4493 fd_set read_fdset;
4494 FD_ZERO (&read_fdset);
4495 FD_SET (read_fd, &read_fdset);
4496 FD_SET (pipe_read_fd, &read_fdset);
4497 const int nfds = std::max<int>(read_fd, pipe_read_fd) + 1;
4498 int num_set_fds = select (nfds, &read_fdset, NULL, NULL, NULL);
4499 if (num_set_fds < 0)
4500 {
4501 const int select_errno = errno;
4502
4503 if (select_errno != EINTR)
4504 SetIsDone(true);
4505 }
4506 else if (num_set_fds > 0)
4507 {
4508 char ch = 0;
4509 size_t n;
4510 if (FD_ISSET (read_fd, &read_fdset))
4511 {
4512 n = 1;
4513 if (m_read_file.Read(&ch, n).Success() && n == 1)
4514 {
4515 if (m_write_file.Write(&ch, n).Fail() || n != 1)
4516 SetIsDone(true);
4517 }
4518 else
4519 SetIsDone(true);
4520 }
4521 if (FD_ISSET (pipe_read_fd, &read_fdset))
4522 {
4523 // Consume the interrupt byte
Greg Clayton100eb932014-07-02 21:10:39 +00004524 if (m_pipe.Read (&ch, 1) == 1)
Greg Clayton19e11352014-02-26 22:47:33 +00004525 {
Greg Clayton100eb932014-07-02 21:10:39 +00004526 switch (ch)
4527 {
4528 case 'q':
4529 SetIsDone(true);
4530 break;
4531 case 'i':
4532 if (StateIsRunningState(m_process->GetState()))
4533 m_process->Halt();
4534 break;
4535 }
Greg Clayton19e11352014-02-26 22:47:33 +00004536 }
Greg Clayton44d93782014-01-27 23:43:24 +00004537 }
4538 }
4539 }
Deepak Panickal914b8d92014-01-31 18:48:46 +00004540#endif
Greg Clayton44d93782014-01-27 23:43:24 +00004541 terminal_state.Restore();
4542
4543 }
4544 else
4545 SetIsDone(true);
4546 }
4547 else
4548 SetIsDone(true);
4549 }
4550
4551 // Hide any characters that have been displayed so far so async
4552 // output can be displayed. Refresh() will be called after the
4553 // output has been displayed.
4554 virtual void
4555 Hide ()
4556 {
4557
4558 }
4559 // Called when the async output has been received in order to update
4560 // the input reader (refresh the prompt and redisplay any current
4561 // line(s) that are being edited
4562 virtual void
4563 Refresh ()
4564 {
4565
4566 }
Greg Claytone68f5d62014-02-24 22:50:57 +00004567
Greg Clayton44d93782014-01-27 23:43:24 +00004568 virtual void
Greg Claytone68f5d62014-02-24 22:50:57 +00004569 Cancel ()
Greg Clayton44d93782014-01-27 23:43:24 +00004570 {
Greg Clayton19e11352014-02-26 22:47:33 +00004571 char ch = 'q'; // Send 'q' for quit
Greg Clayton100eb932014-07-02 21:10:39 +00004572 m_pipe.Write (&ch, 1);
Greg Clayton44d93782014-01-27 23:43:24 +00004573 }
Greg Claytone68f5d62014-02-24 22:50:57 +00004574
Greg Claytonf0066ad2014-05-02 00:45:31 +00004575 virtual bool
Greg Claytone68f5d62014-02-24 22:50:57 +00004576 Interrupt ()
4577 {
Greg Clayton19e11352014-02-26 22:47:33 +00004578 // Do only things that are safe to do in an interrupt context (like in
4579 // a SIGINT handler), like write 1 byte to a file descriptor. This will
4580 // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
4581 // that was written to the pipe and then call m_process->Halt() from a
4582 // much safer location in code.
Greg Clayton19e11352014-02-26 22:47:33 +00004583 char ch = 'i'; // Send 'i' for interrupt
Greg Clayton100eb932014-07-02 21:10:39 +00004584 return m_pipe.Write (&ch, 1) == 1;
Greg Claytone68f5d62014-02-24 22:50:57 +00004585 }
Greg Clayton44d93782014-01-27 23:43:24 +00004586
4587 virtual void
4588 GotEOF()
4589 {
4590
4591 }
4592
4593protected:
4594 Process *m_process;
4595 File m_read_file; // Read from this file (usually actual STDIN for LLDB
4596 File m_write_file; // Write to this file (usually the master pty for getting io to debuggee)
Greg Clayton100eb932014-07-02 21:10:39 +00004597 Pipe m_pipe;
Greg Clayton44d93782014-01-27 23:43:24 +00004598};
4599
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004600void
Greg Clayton44d93782014-01-27 23:43:24 +00004601Process::SetSTDIOFileDescriptor (int fd)
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004602{
4603 // First set up the Read Thread for reading/handling process I/O
4604
Greg Clayton44d93782014-01-27 23:43:24 +00004605 std::unique_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (fd, true));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004606
4607 if (conn_ap.get())
4608 {
4609 m_stdio_communication.SetConnection (conn_ap.release());
4610 if (m_stdio_communication.IsConnected())
4611 {
4612 m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
4613 m_stdio_communication.StartReadThread();
4614
4615 // Now read thread is set up, set up input reader.
4616
4617 if (!m_process_input_reader.get())
Greg Clayton44d93782014-01-27 23:43:24 +00004618 m_process_input_reader.reset (new IOHandlerProcessSTDIO (this, fd));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004619 }
4620 }
4621}
4622
Greg Claytonb4874f12014-02-28 18:22:24 +00004623bool
Greg Clayton6fea17e2014-03-03 19:15:20 +00004624Process::ProcessIOHandlerIsActive ()
4625{
4626 IOHandlerSP io_handler_sp (m_process_input_reader);
4627 if (io_handler_sp)
4628 return m_target.GetDebugger().IsTopIOHandler (io_handler_sp);
4629 return false;
4630}
4631bool
Greg Clayton44d93782014-01-27 23:43:24 +00004632Process::PushProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004633{
Greg Clayton44d93782014-01-27 23:43:24 +00004634 IOHandlerSP io_handler_sp (m_process_input_reader);
4635 if (io_handler_sp)
4636 {
4637 io_handler_sp->SetIsDone(false);
4638 m_target.GetDebugger().PushIOHandler (io_handler_sp);
Greg Claytonb4874f12014-02-28 18:22:24 +00004639 return true;
Greg Clayton44d93782014-01-27 23:43:24 +00004640 }
Greg Claytonb4874f12014-02-28 18:22:24 +00004641 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004642}
4643
Greg Claytonb4874f12014-02-28 18:22:24 +00004644bool
Greg Clayton44d93782014-01-27 23:43:24 +00004645Process::PopProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004646{
Greg Clayton44d93782014-01-27 23:43:24 +00004647 IOHandlerSP io_handler_sp (m_process_input_reader);
4648 if (io_handler_sp)
Greg Claytonb4874f12014-02-28 18:22:24 +00004649 return m_target.GetDebugger().PopIOHandler (io_handler_sp);
4650 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004651}
4652
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00004653// The process needs to know about installed plug-ins
Greg Clayton99d0faf2010-11-18 23:32:35 +00004654void
Caroline Tice20bd37f2011-03-10 22:14:10 +00004655Process::SettingsInitialize ()
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004656{
Greg Clayton6920b522012-08-22 18:39:03 +00004657 Thread::SettingsInitialize ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00004658}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004659
Greg Clayton99d0faf2010-11-18 23:32:35 +00004660void
Caroline Tice20bd37f2011-03-10 22:14:10 +00004661Process::SettingsTerminate ()
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00004662{
Greg Clayton6920b522012-08-22 18:39:03 +00004663 Thread::SettingsTerminate ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00004664}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00004665
Jim Ingham1624a2d2014-05-05 02:26:40 +00004666ExpressionResults
Jim Inghamf48169b2010-11-30 02:22:11 +00004667Process::RunThreadPlan (ExecutionContext &exe_ctx,
Jim Ingham372787f2012-04-07 00:00:41 +00004668 lldb::ThreadPlanSP &thread_plan_sp,
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004669 const EvaluateExpressionOptions &options,
Jim Inghamf48169b2010-11-30 02:22:11 +00004670 Stream &errors)
4671{
Jim Ingham8646d3c2014-05-05 02:47:44 +00004672 ExpressionResults return_value = eExpressionSetupError;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004673
Jim Ingham77787032011-01-20 02:03:18 +00004674 if (thread_plan_sp.get() == NULL)
4675 {
4676 errors.Printf("RunThreadPlan called with empty thread plan.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004677 return eExpressionSetupError;
Jim Ingham77787032011-01-20 02:03:18 +00004678 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004679
Jim Ingham7d7931d2013-03-28 00:05:34 +00004680 if (!thread_plan_sp->ValidatePlan(NULL))
4681 {
4682 errors.Printf ("RunThreadPlan called with an invalid thread plan.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004683 return eExpressionSetupError;
Jim Ingham7d7931d2013-03-28 00:05:34 +00004684 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004685
Greg Claytonc14ee322011-09-22 04:58:26 +00004686 if (exe_ctx.GetProcessPtr() != this)
4687 {
4688 errors.Printf("RunThreadPlan called on wrong process.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004689 return eExpressionSetupError;
Greg Claytonc14ee322011-09-22 04:58:26 +00004690 }
4691
4692 Thread *thread = exe_ctx.GetThreadPtr();
4693 if (thread == NULL)
4694 {
4695 errors.Printf("RunThreadPlan called with invalid thread.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004696 return eExpressionSetupError;
Greg Claytonc14ee322011-09-22 04:58:26 +00004697 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004698
Jim Ingham17e5c4e2011-05-17 22:24:54 +00004699 // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes.
4700 // For that to be true the plan can't be private - since private plans suppress themselves in the
4701 // GetCompletedPlan call.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004702
Jim Ingham17e5c4e2011-05-17 22:24:54 +00004703 bool orig_plan_private = thread_plan_sp->GetPrivate();
4704 thread_plan_sp->SetPrivate(false);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004705
Jim Ingham444586b2011-01-24 06:34:17 +00004706 if (m_private_state.GetValue() != eStateStopped)
4707 {
4708 errors.Printf ("RunThreadPlan called while the private state was not stopped.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004709 return eExpressionSetupError;
Jim Ingham444586b2011-01-24 06:34:17 +00004710 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004711
Jim Ingham66243842011-08-13 00:56:10 +00004712 // Save the thread & frame from the exe_ctx for restoration after we run
Greg Claytonc14ee322011-09-22 04:58:26 +00004713 const uint32_t thread_idx_id = thread->GetIndexID();
Jason Molendab57e4a12013-11-04 09:33:30 +00004714 StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
Jim Ingham11b0e052013-02-19 23:22:45 +00004715 if (!selected_frame_sp)
4716 {
4717 thread->SetSelectedFrame(0);
4718 selected_frame_sp = thread->GetSelectedFrame();
4719 if (!selected_frame_sp)
4720 {
4721 errors.Printf("RunThreadPlan called without a selected frame on thread %d", thread_idx_id);
Jim Ingham8646d3c2014-05-05 02:47:44 +00004722 return eExpressionSetupError;
Jim Ingham11b0e052013-02-19 23:22:45 +00004723 }
4724 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004725
Jim Ingham11b0e052013-02-19 23:22:45 +00004726 StackID ctx_frame_id = selected_frame_sp->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00004727
4728 // N.B. Running the target may unset the currently selected thread and frame. We don't want to do that either,
4729 // so we should arrange to reset them as well.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004730
Greg Claytonc14ee322011-09-22 04:58:26 +00004731 lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004732
Jim Ingham66243842011-08-13 00:56:10 +00004733 uint32_t selected_tid;
4734 StackID selected_stack_id;
Greg Clayton762f7132011-09-18 18:59:15 +00004735 if (selected_thread_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00004736 {
4737 selected_tid = selected_thread_sp->GetIndexID();
Jim Ingham66243842011-08-13 00:56:10 +00004738 selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00004739 }
4740 else
4741 {
4742 selected_tid = LLDB_INVALID_THREAD_ID;
4743 }
4744
Jim Ingham372787f2012-04-07 00:00:41 +00004745 lldb::thread_t backup_private_state_thread = LLDB_INVALID_HOST_THREAD;
Jim Ingham076b3042012-04-10 01:21:57 +00004746 lldb::StateType old_state;
4747 lldb::ThreadPlanSP stopper_base_plan_sp;
Jim Ingham372787f2012-04-07 00:00:41 +00004748
Greg Clayton5160ce52013-03-27 23:08:40 +00004749 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham372787f2012-04-07 00:00:41 +00004750 if (Host::GetCurrentThread() == m_private_state_thread)
4751 {
Jim Ingham076b3042012-04-10 01:21:57 +00004752 // Yikes, we are running on the private state thread! So we can't wait for public events on this thread, since
4753 // we are the thread that is generating public events.
Jim Ingham372787f2012-04-07 00:00:41 +00004754 // 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 +00004755 // we are fielding public events here.
4756 if (log)
Jason Molendad251c9d2012-11-17 01:41:04 +00004757 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 +00004758
Jim Ingham372787f2012-04-07 00:00:41 +00004759 backup_private_state_thread = m_private_state_thread;
Jim Ingham076b3042012-04-10 01:21:57 +00004760
4761 // One other bit of business: we want to run just this thread plan and anything it pushes, and then stop,
4762 // returning control here.
4763 // But in the normal course of things, the plan above us on the stack would be given a shot at the stop
4764 // event before deciding to stop, and we don't want that. So we insert a "stopper" base plan on the stack
4765 // before the plan we want to run. Since base plans always stop and return control to the user, that will
4766 // do just what we want.
4767 stopper_base_plan_sp.reset(new ThreadPlanBase (*thread));
4768 thread->QueueThreadPlan (stopper_base_plan_sp, false);
4769 // Have to make sure our public state is stopped, since otherwise the reporting logic below doesn't work correctly.
4770 old_state = m_public_state.GetValue();
4771 m_public_state.SetValueNoLock(eStateStopped);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004772
Jim Ingham076b3042012-04-10 01:21:57 +00004773 // Now spin up the private state thread:
Jim Ingham372787f2012-04-07 00:00:41 +00004774 StartPrivateStateThread(true);
4775 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004776
Jim Ingham372787f2012-04-07 00:00:41 +00004777 thread->QueueThreadPlan(thread_plan_sp, false); // This used to pass "true" does that make sense?
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004778
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004779 if (options.GetDebug())
4780 {
4781 // In this case, we aren't actually going to run, we just want to stop right away.
4782 // Flush this thread so we will refetch the stacks and show the correct backtrace.
4783 // FIXME: To make this prettier we should invent some stop reason for this, but that
4784 // is only cosmetic, and this functionality is only of use to lldb developers who can
4785 // live with not pretty...
4786 thread->Flush();
Jim Ingham8646d3c2014-05-05 02:47:44 +00004787 return eExpressionStoppedForDebug;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004788 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004789
Jim Ingham1e7a9ee2011-01-23 21:14:08 +00004790 Listener listener("lldb.process.listener.run-thread-plan");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004791
Sean Callanana46ec452012-07-11 21:31:24 +00004792 lldb::EventSP event_to_broadcast_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004793
Jim Ingham77787032011-01-20 02:03:18 +00004794 {
Sean Callanana46ec452012-07-11 21:31:24 +00004795 // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get
4796 // restored on exit to the function.
4797 //
4798 // If the event needs to propagate beyond the hijacker (e.g., the process exits during execution), then the event
4799 // is put into event_to_broadcast_sp for rebroadcasting.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004800
Sean Callanana46ec452012-07-11 21:31:24 +00004801 ProcessEventHijacker run_thread_plan_hijacker (*this, &listener);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004802
Jim Inghamf48169b2010-11-30 02:22:11 +00004803 if (log)
Jim Ingham0f16e732011-02-08 05:20:59 +00004804 {
4805 StreamString s;
Sean Callanana46ec452012-07-11 21:31:24 +00004806 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
Daniel Malead01b2952012-11-29 21:49:15 +00004807 log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64 " to run thread plan \"%s\".",
Sean Callanana46ec452012-07-11 21:31:24 +00004808 thread->GetIndexID(),
4809 thread->GetID(),
4810 s.GetData());
4811 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004812
Sean Callanana46ec452012-07-11 21:31:24 +00004813 bool got_event;
4814 lldb::EventSP event_sp;
4815 lldb::StateType stop_state = lldb::eStateInvalid;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004816
Sean Callanana46ec452012-07-11 21:31:24 +00004817 TimeValue* timeout_ptr = NULL;
4818 TimeValue real_timeout;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004819
Jim Ingham0161b492013-02-09 01:29:05 +00004820 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 +00004821 bool do_resume = true;
Jim Ingham184e9812013-01-15 02:47:48 +00004822 bool handle_running_event = true;
Jim Ingham35e1bda2012-10-16 21:41:58 +00004823 const uint64_t default_one_thread_timeout_usec = 250000;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004824
Jim Ingham0161b492013-02-09 01:29:05 +00004825 // This is just for accounting:
4826 uint32_t num_resumes = 0;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004827
Jim Ingham6fbc48b2013-11-07 00:11:47 +00004828 uint32_t timeout_usec = options.GetTimeoutUsec();
Jim Inghamfd95f892014-04-22 01:41:52 +00004829 uint32_t one_thread_timeout_usec;
4830 uint32_t all_threads_timeout_usec = 0;
Jim Inghamfe1c3422014-04-16 02:24:48 +00004831
4832 // If we are going to run all threads the whole time, or if we are only going to run one thread,
4833 // then we don't need the first timeout. So we set the final timeout, and pretend we are after the
4834 // first timeout already.
4835
4836 if (!options.GetStopOthers() || !options.GetTryAllThreads())
Jim Ingham286fb1e2014-02-28 02:52:06 +00004837 {
4838 before_first_timeout = false;
Jim Inghamfd95f892014-04-22 01:41:52 +00004839 one_thread_timeout_usec = 0;
4840 all_threads_timeout_usec = timeout_usec;
Jim Ingham286fb1e2014-02-28 02:52:06 +00004841 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00004842 else
Jim Ingham0161b492013-02-09 01:29:05 +00004843 {
Jim Inghamfd95f892014-04-22 01:41:52 +00004844 uint32_t option_one_thread_timeout = options.GetOneThreadTimeoutUsec();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004845
Jim Ingham914f4e72014-03-28 21:58:28 +00004846 // If the overall wait is forever, then we only need to set the one thread timeout:
4847 if (timeout_usec == 0)
4848 {
Ed Maste801335c2014-03-31 19:28:14 +00004849 if (option_one_thread_timeout != 0)
Jim Inghamfd95f892014-04-22 01:41:52 +00004850 one_thread_timeout_usec = option_one_thread_timeout;
Jim Ingham914f4e72014-03-28 21:58:28 +00004851 else
Jim Inghamfd95f892014-04-22 01:41:52 +00004852 one_thread_timeout_usec = default_one_thread_timeout_usec;
Jim Ingham914f4e72014-03-28 21:58:28 +00004853 }
Jim Ingham0161b492013-02-09 01:29:05 +00004854 else
4855 {
Jim Ingham914f4e72014-03-28 21:58:28 +00004856 // Otherwise, if the one thread timeout is set, make sure it isn't longer than the overall timeout,
4857 // and use it, otherwise use half the total timeout, bounded by the default_one_thread_timeout_usec.
4858 uint64_t computed_one_thread_timeout;
4859 if (option_one_thread_timeout != 0)
4860 {
4861 if (timeout_usec < option_one_thread_timeout)
4862 {
4863 errors.Printf("RunThreadPlan called without one thread timeout greater than total timeout");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004864 return eExpressionSetupError;
Jim Ingham914f4e72014-03-28 21:58:28 +00004865 }
4866 computed_one_thread_timeout = option_one_thread_timeout;
4867 }
4868 else
4869 {
4870 computed_one_thread_timeout = timeout_usec / 2;
4871 if (computed_one_thread_timeout > default_one_thread_timeout_usec)
4872 computed_one_thread_timeout = default_one_thread_timeout_usec;
4873 }
Jim Inghamfd95f892014-04-22 01:41:52 +00004874 one_thread_timeout_usec = computed_one_thread_timeout;
4875 all_threads_timeout_usec = timeout_usec - one_thread_timeout_usec;
4876
Jim Ingham0161b492013-02-09 01:29:05 +00004877 }
Jim Ingham0161b492013-02-09 01:29:05 +00004878 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00004879
4880 if (log)
Jim Inghamfd95f892014-04-22 01:41:52 +00004881 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 +00004882 options.GetStopOthers(),
4883 options.GetTryAllThreads(),
Jim Inghamfd95f892014-04-22 01:41:52 +00004884 before_first_timeout,
4885 one_thread_timeout_usec,
4886 all_threads_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00004887
Jim Ingham1460e4b2014-01-10 23:46:59 +00004888 // This isn't going to work if there are unfetched events on the queue.
4889 // Are there cases where we might want to run the remaining events here, and then try to
4890 // call the function? That's probably being too tricky for our own good.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004891
Jim Ingham1460e4b2014-01-10 23:46:59 +00004892 Event *other_events = listener.PeekAtNextEvent();
4893 if (other_events != NULL)
4894 {
4895 errors.Printf("Calling RunThreadPlan with pending events on the queue.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00004896 return eExpressionSetupError;
Jim Ingham1460e4b2014-01-10 23:46:59 +00004897 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004898
Jim Ingham1460e4b2014-01-10 23:46:59 +00004899 // We also need to make sure that the next event is delivered. We might be calling a function as part of
4900 // a thread plan, in which case the last delivered event could be the running event, and we don't want
4901 // event coalescing to cause us to lose OUR running event...
4902 ForceNextEventDelivery();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004903
Jim Ingham8559a352012-11-26 23:52:18 +00004904 // This while loop must exit out the bottom, there's cleanup that we need to do when we are done.
4905 // So don't call return anywhere within it.
Jim Ingham35878c42014-04-08 21:33:21 +00004906
4907#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
4908 // It's pretty much impossible to write test cases for things like:
4909 // One thread timeout expires, I go to halt, but the process already stopped
4910 // on the function call stop breakpoint. Turning on this define will make us not
4911 // fetch the first event till after the halt. So if you run a quick function, it will have
4912 // completed, and the completion event will be waiting, when you interrupt for halt.
4913 // The expression evaluation should still succeed.
4914 bool miss_first_event = true;
4915#endif
Jim Inghamfd95f892014-04-22 01:41:52 +00004916 TimeValue one_thread_timeout;
4917 TimeValue final_timeout;
4918
Jim Ingham35878c42014-04-08 21:33:21 +00004919
Sean Callanana46ec452012-07-11 21:31:24 +00004920 while (1)
4921 {
4922 // We usually want to resume the process if we get to the top of the loop.
4923 // The only exception is if we get two running events with no intervening
4924 // stop, which can happen, we will just wait for then next stop event.
Jim Ingham0161b492013-02-09 01:29:05 +00004925 if (log)
4926 log->Printf ("Top of while loop: do_resume: %i handle_running_event: %i before_first_timeout: %i.",
4927 do_resume,
4928 handle_running_event,
4929 before_first_timeout);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004930
Jim Ingham184e9812013-01-15 02:47:48 +00004931 if (do_resume || handle_running_event)
Sean Callanana46ec452012-07-11 21:31:24 +00004932 {
4933 // Do the initial resume and wait for the running event before going further.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004934
Jim Ingham184e9812013-01-15 02:47:48 +00004935 if (do_resume)
Sean Callanana46ec452012-07-11 21:31:24 +00004936 {
Jim Ingham0161b492013-02-09 01:29:05 +00004937 num_resumes++;
Jim Ingham184e9812013-01-15 02:47:48 +00004938 Error resume_error = PrivateResume ();
4939 if (!resume_error.Success())
4940 {
Jim Ingham0161b492013-02-09 01:29:05 +00004941 errors.Printf("Error resuming inferior the %d time: \"%s\".\n",
4942 num_resumes,
4943 resume_error.AsCString());
Jim Ingham8646d3c2014-05-05 02:47:44 +00004944 return_value = eExpressionSetupError;
Jim Ingham184e9812013-01-15 02:47:48 +00004945 break;
4946 }
Sean Callanana46ec452012-07-11 21:31:24 +00004947 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004948
Jim Ingham0161b492013-02-09 01:29:05 +00004949 TimeValue resume_timeout = TimeValue::Now();
4950 resume_timeout.OffsetWithMicroSeconds(500000);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004951
Jim Ingham0161b492013-02-09 01:29:05 +00004952 got_event = listener.WaitForEvent(&resume_timeout, event_sp);
Sean Callanana46ec452012-07-11 21:31:24 +00004953 if (!got_event)
4954 {
4955 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00004956 log->Printf ("Process::RunThreadPlan(): didn't get any event after resume %d, exiting.",
4957 num_resumes);
Sean Callanana46ec452012-07-11 21:31:24 +00004958
Jim Ingham0161b492013-02-09 01:29:05 +00004959 errors.Printf("Didn't get any event after resume %d, exiting.", num_resumes);
Jim Ingham8646d3c2014-05-05 02:47:44 +00004960 return_value = eExpressionSetupError;
Sean Callanana46ec452012-07-11 21:31:24 +00004961 break;
4962 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004963
Sean Callanana46ec452012-07-11 21:31:24 +00004964 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Ingham0161b492013-02-09 01:29:05 +00004965
Sean Callanana46ec452012-07-11 21:31:24 +00004966 if (stop_state != eStateRunning)
4967 {
Jim Ingham0161b492013-02-09 01:29:05 +00004968 bool restarted = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004969
Jim Ingham0161b492013-02-09 01:29:05 +00004970 if (stop_state == eStateStopped)
4971 {
4972 restarted = Process::ProcessEventData::GetRestartedFromEvent(event_sp.get());
4973 if (log)
4974 log->Printf("Process::RunThreadPlan(): didn't get running event after "
4975 "resume %d, got %s instead (restarted: %i, do_resume: %i, handle_running_event: %i).",
4976 num_resumes,
4977 StateAsCString(stop_state),
4978 restarted,
4979 do_resume,
4980 handle_running_event);
4981 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004982
Jim Ingham0161b492013-02-09 01:29:05 +00004983 if (restarted)
4984 {
4985 // This is probably an overabundance of caution, I don't think I should ever get a stopped & restarted
4986 // event here. But if I do, the best thing is to Halt and then get out of here.
4987 Halt();
4988 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004989
Jim Ingham35e1bda2012-10-16 21:41:58 +00004990 errors.Printf("Didn't get running event after initial resume, got %s instead.",
4991 StateAsCString(stop_state));
Jim Ingham8646d3c2014-05-05 02:47:44 +00004992 return_value = eExpressionSetupError;
Sean Callanana46ec452012-07-11 21:31:24 +00004993 break;
4994 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004995
Sean Callanana46ec452012-07-11 21:31:24 +00004996 if (log)
4997 log->PutCString ("Process::RunThreadPlan(): resuming succeeded.");
4998 // We need to call the function synchronously, so spin waiting for it to return.
4999 // If we get interrupted while executing, we're going to lose our context, and
5000 // won't be able to gather the result at this point.
5001 // We set the timeout AFTER the resume, since the resume takes some time and we
5002 // don't want to charge that to the timeout.
Sean Callanana46ec452012-07-11 21:31:24 +00005003 }
Jim Ingham0f16e732011-02-08 05:20:59 +00005004 else
5005 {
Sean Callanana46ec452012-07-11 21:31:24 +00005006 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005007 log->PutCString ("Process::RunThreadPlan(): waiting for next event.");
Jim Ingham0f16e732011-02-08 05:20:59 +00005008 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005009
Jim Ingham0161b492013-02-09 01:29:05 +00005010 if (before_first_timeout)
5011 {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005012 if (options.GetTryAllThreads())
Jim Inghamfd95f892014-04-22 01:41:52 +00005013 {
5014 one_thread_timeout = TimeValue::Now();
5015 one_thread_timeout.OffsetWithMicroSeconds(one_thread_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005016 timeout_ptr = &one_thread_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005017 }
Jim Ingham0161b492013-02-09 01:29:05 +00005018 else
5019 {
5020 if (timeout_usec == 0)
5021 timeout_ptr = NULL;
5022 else
Jim Inghamfd95f892014-04-22 01:41:52 +00005023 {
5024 final_timeout = TimeValue::Now();
5025 final_timeout.OffsetWithMicroSeconds (timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005026 timeout_ptr = &final_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005027 }
Jim Ingham0161b492013-02-09 01:29:05 +00005028 }
5029 }
5030 else
5031 {
5032 if (timeout_usec == 0)
5033 timeout_ptr = NULL;
5034 else
Jim Inghamfd95f892014-04-22 01:41:52 +00005035 {
5036 final_timeout = TimeValue::Now();
5037 final_timeout.OffsetWithMicroSeconds (all_threads_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005038 timeout_ptr = &final_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005039 }
Jim Ingham0161b492013-02-09 01:29:05 +00005040 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005041
Jim Ingham0161b492013-02-09 01:29:05 +00005042 do_resume = true;
5043 handle_running_event = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005044
Sean Callanana46ec452012-07-11 21:31:24 +00005045 // Now wait for the process to stop again:
Sean Callanana46ec452012-07-11 21:31:24 +00005046 event_sp.reset();
Jim Ingham0f16e732011-02-08 05:20:59 +00005047
Jim Ingham0f16e732011-02-08 05:20:59 +00005048 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00005049 {
Sean Callanana46ec452012-07-11 21:31:24 +00005050 if (timeout_ptr)
5051 {
Matt Kopec676a4872013-02-21 23:55:31 +00005052 log->Printf ("Process::RunThreadPlan(): about to wait - now is %" PRIu64 " - endpoint is %" PRIu64,
Jim Ingham0161b492013-02-09 01:29:05 +00005053 TimeValue::Now().GetAsMicroSecondsSinceJan1_1970(),
5054 timeout_ptr->GetAsMicroSecondsSinceJan1_1970());
Sean Callanana46ec452012-07-11 21:31:24 +00005055 }
Jim Ingham20829ac2011-08-09 22:24:33 +00005056 else
Sean Callanana46ec452012-07-11 21:31:24 +00005057 {
5058 log->Printf ("Process::RunThreadPlan(): about to wait forever.");
5059 }
5060 }
Jim Ingham35878c42014-04-08 21:33:21 +00005061
5062#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5063 // See comment above...
5064 if (miss_first_event)
5065 {
5066 usleep(1000);
5067 miss_first_event = false;
5068 got_event = false;
5069 }
5070 else
5071#endif
Sean Callanana46ec452012-07-11 21:31:24 +00005072 got_event = listener.WaitForEvent (timeout_ptr, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005073
Sean Callanana46ec452012-07-11 21:31:24 +00005074 if (got_event)
5075 {
5076 if (event_sp.get())
5077 {
5078 bool keep_going = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005079 if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005080 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005081 Halt();
Jim Ingham8646d3c2014-05-05 02:47:44 +00005082 return_value = eExpressionInterrupted;
Jim Inghamcfc09352012-07-27 23:57:19 +00005083 errors.Printf ("Execution halted by user interrupt.");
5084 if (log)
5085 log->Printf ("Process::RunThreadPlan(): Got interrupted by eBroadcastBitInterrupted, exiting.");
Jim Ingham0161b492013-02-09 01:29:05 +00005086 break;
Jim Inghamcfc09352012-07-27 23:57:19 +00005087 }
5088 else
5089 {
5090 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5091 if (log)
5092 log->Printf("Process::RunThreadPlan(): in while loop, got event: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005093
Jim Inghamcfc09352012-07-27 23:57:19 +00005094 switch (stop_state)
Sean Callanana46ec452012-07-11 21:31:24 +00005095 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005096 case lldb::eStateStopped:
Sean Callanana46ec452012-07-11 21:31:24 +00005097 {
Jim Ingham0161b492013-02-09 01:29:05 +00005098 // We stopped, figure out what we are going to do now.
Jim Inghamcfc09352012-07-27 23:57:19 +00005099 ThreadSP thread_sp = GetThreadList().FindThreadByIndexID (thread_idx_id);
5100 if (!thread_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005101 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005102 // Ooh, our thread has vanished. Unlikely that this was successful execution...
Sean Callanana46ec452012-07-11 21:31:24 +00005103 if (log)
Jim Inghamcfc09352012-07-27 23:57:19 +00005104 log->Printf ("Process::RunThreadPlan(): execution completed but our thread (index-id=%u) has vanished.", thread_idx_id);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005105 return_value = eExpressionInterrupted;
Sean Callanana46ec452012-07-11 21:31:24 +00005106 }
5107 else
5108 {
Jim Ingham0161b492013-02-09 01:29:05 +00005109 // If we were restarted, we just need to go back up to fetch another event.
5110 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
Jim Inghamcfc09352012-07-27 23:57:19 +00005111 {
5112 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005113 {
5114 log->Printf ("Process::RunThreadPlan(): Got a stop and restart, so we'll continue waiting.");
5115 }
5116 keep_going = true;
5117 do_resume = false;
5118 handle_running_event = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005119
Jim Inghamcfc09352012-07-27 23:57:19 +00005120 }
5121 else
5122 {
Jim Ingham0161b492013-02-09 01:29:05 +00005123 StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
5124 StopReason stop_reason = eStopReasonInvalid;
5125 if (stop_info_sp)
5126 stop_reason = stop_info_sp->GetStopReason();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005127
Jim Ingham0161b492013-02-09 01:29:05 +00005128 // FIXME: We only check if the stop reason is plan complete, should we make sure that
5129 // it is OUR plan that is complete?
5130 if (stop_reason == eStopReasonPlanComplete)
Jim Ingham184e9812013-01-15 02:47:48 +00005131 {
5132 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005133 log->PutCString ("Process::RunThreadPlan(): execution completed successfully.");
5134 // Now mark this plan as private so it doesn't get reported as the stop reason
5135 // after this point.
5136 if (thread_plan_sp)
5137 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005138 return_value = eExpressionCompleted;
Jim Ingham184e9812013-01-15 02:47:48 +00005139 }
5140 else
5141 {
Jim Ingham0161b492013-02-09 01:29:05 +00005142 // Something restarted the target, so just wait for it to stop for real.
Jim Ingham184e9812013-01-15 02:47:48 +00005143 if (stop_reason == eStopReasonBreakpoint)
Jim Ingham0161b492013-02-09 01:29:05 +00005144 {
5145 if (log)
5146 log->Printf ("Process::RunThreadPlan() stopped for breakpoint: %s.", stop_info_sp->GetDescription());
Jim Ingham8646d3c2014-05-05 02:47:44 +00005147 return_value = eExpressionHitBreakpoint;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005148 if (!options.DoesIgnoreBreakpoints())
Sean Callanan4b388c92013-07-30 19:54:09 +00005149 {
5150 event_to_broadcast_sp = event_sp;
5151 }
Jim Ingham0161b492013-02-09 01:29:05 +00005152 }
Jim Ingham184e9812013-01-15 02:47:48 +00005153 else
Jim Ingham0161b492013-02-09 01:29:05 +00005154 {
5155 if (log)
5156 log->PutCString ("Process::RunThreadPlan(): thread plan didn't successfully complete.");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005157 if (!options.DoesUnwindOnError())
Sean Callanan4b388c92013-07-30 19:54:09 +00005158 event_to_broadcast_sp = event_sp;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005159 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005160 }
Jim Ingham184e9812013-01-15 02:47:48 +00005161 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005162 }
Sean Callanana46ec452012-07-11 21:31:24 +00005163 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005164 }
5165 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005166
Jim Inghamcfc09352012-07-27 23:57:19 +00005167 case lldb::eStateRunning:
Jim Ingham0161b492013-02-09 01:29:05 +00005168 // This shouldn't really happen, but sometimes we do get two running events without an
5169 // intervening stop, and in that case we should just go back to waiting for the stop.
Jim Inghamcfc09352012-07-27 23:57:19 +00005170 do_resume = false;
5171 keep_going = true;
Jim Ingham184e9812013-01-15 02:47:48 +00005172 handle_running_event = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005173 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005174
Jim Inghamcfc09352012-07-27 23:57:19 +00005175 default:
5176 if (log)
5177 log->Printf("Process::RunThreadPlan(): execution stopped with unexpected state: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005178
Jim Inghamcfc09352012-07-27 23:57:19 +00005179 if (stop_state == eStateExited)
5180 event_to_broadcast_sp = event_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005181
Sean Callananbf154da2012-08-08 17:35:10 +00005182 errors.Printf ("Execution stopped with unexpected state.\n");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005183 return_value = eExpressionInterrupted;
Jim Inghamcfc09352012-07-27 23:57:19 +00005184 break;
5185 }
Sean Callanana46ec452012-07-11 21:31:24 +00005186 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005187
Sean Callanana46ec452012-07-11 21:31:24 +00005188 if (keep_going)
5189 continue;
5190 else
5191 break;
5192 }
5193 else
5194 {
5195 if (log)
5196 log->PutCString ("Process::RunThreadPlan(): got_event was true, but the event pointer was null. How odd...");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005197 return_value = eExpressionInterrupted;
Sean Callanana46ec452012-07-11 21:31:24 +00005198 break;
5199 }
5200 }
5201 else
5202 {
5203 // If we didn't get an event that means we've timed out...
5204 // We will interrupt the process here. Depending on what we were asked to do we will
5205 // either exit, or try with all threads running for the same timeout.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005206
Sean Callanana46ec452012-07-11 21:31:24 +00005207 if (log) {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005208 if (options.GetTryAllThreads())
Sean Callanana46ec452012-07-11 21:31:24 +00005209 {
Jim Ingham0161b492013-02-09 01:29:05 +00005210 if (before_first_timeout)
Jim Inghamfe1c3422014-04-16 02:24:48 +00005211 {
5212 if (timeout_usec != 0)
5213 {
Jim Inghamfe1c3422014-04-16 02:24:48 +00005214 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
Jim Inghamfd95f892014-04-22 01:41:52 +00005215 "running for %" PRIu32 " usec with all threads enabled.",
5216 all_threads_timeout_usec);
Jim Inghamfe1c3422014-04-16 02:24:48 +00005217 }
5218 else
5219 {
5220 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
Ed Mastee61c7b02014-04-29 17:48:06 +00005221 "running forever with all threads enabled.");
Jim Inghamfe1c3422014-04-16 02:24:48 +00005222 }
5223 }
Sean Callanana46ec452012-07-11 21:31:24 +00005224 else
5225 log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled "
Jason Molenda6a8658a2013-10-27 02:32:23 +00005226 "and timeout: %u timed out, abandoning execution.",
Jim Ingham35e1bda2012-10-16 21:41:58 +00005227 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005228 }
5229 else
Jason Molenda6a8658a2013-10-27 02:32:23 +00005230 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %u timed out, "
Jim Ingham35e1bda2012-10-16 21:41:58 +00005231 "abandoning execution.",
5232 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005233 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005234
Jim Ingham0161b492013-02-09 01:29:05 +00005235 // It is possible that between the time we issued the Halt, and we get around to calling Halt the target
5236 // could have stopped. That's fine, Halt will figure that out and send the appropriate Stopped event.
5237 // BUT it is also possible that we stopped & restarted (e.g. hit a signal with "stop" set to false.) In
5238 // that case, we'll get the stopped & restarted event, and we should go back to waiting for the Halt's
5239 // stopped event. That's what this while loop does.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005240
Jim Ingham0161b492013-02-09 01:29:05 +00005241 bool back_to_top = true;
5242 uint32_t try_halt_again = 0;
5243 bool do_halt = true;
5244 const uint32_t num_retries = 5;
5245 while (try_halt_again < num_retries)
Sean Callanana46ec452012-07-11 21:31:24 +00005246 {
Jim Ingham0161b492013-02-09 01:29:05 +00005247 Error halt_error;
5248 if (do_halt)
5249 {
5250 if (log)
5251 log->Printf ("Process::RunThreadPlan(): Running Halt.");
5252 halt_error = Halt();
5253 }
5254 if (halt_error.Success())
5255 {
5256 if (log)
5257 log->PutCString ("Process::RunThreadPlan(): Halt succeeded.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005258
Jim Ingham0161b492013-02-09 01:29:05 +00005259 real_timeout = TimeValue::Now();
5260 real_timeout.OffsetWithMicroSeconds(500000);
5261
5262 got_event = listener.WaitForEvent(&real_timeout, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005263
Jim Ingham0161b492013-02-09 01:29:05 +00005264 if (got_event)
Sean Callanana46ec452012-07-11 21:31:24 +00005265 {
Jim Ingham0161b492013-02-09 01:29:05 +00005266 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5267 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00005268 {
Jim Ingham0161b492013-02-09 01:29:05 +00005269 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state));
5270 if (stop_state == lldb::eStateStopped
5271 && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
5272 log->PutCString (" Event was the Halt interruption event.");
Sean Callanana46ec452012-07-11 21:31:24 +00005273 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005274
Jim Ingham0161b492013-02-09 01:29:05 +00005275 if (stop_state == lldb::eStateStopped)
Sean Callanana46ec452012-07-11 21:31:24 +00005276 {
Jim Ingham0161b492013-02-09 01:29:05 +00005277 // Between the time we initiated the Halt and the time we delivered it, the process could have
5278 // already finished its job. Check that here:
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005279
Jim Ingham0161b492013-02-09 01:29:05 +00005280 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
5281 {
5282 if (log)
5283 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
5284 "Exiting wait loop.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005285 return_value = eExpressionCompleted;
Jim Ingham0161b492013-02-09 01:29:05 +00005286 back_to_top = false;
5287 break;
5288 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005289
Jim Ingham0161b492013-02-09 01:29:05 +00005290 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
5291 {
5292 if (log)
5293 log->PutCString ("Process::RunThreadPlan(): Went to halt but got a restarted event, there must be an un-restarted stopped event so try again... "
5294 "Exiting wait loop.");
5295 try_halt_again++;
5296 do_halt = false;
5297 continue;
5298 }
Sean Callanana46ec452012-07-11 21:31:24 +00005299
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005300 if (!options.GetTryAllThreads())
Jim Ingham0161b492013-02-09 01:29:05 +00005301 {
5302 if (log)
5303 log->PutCString ("Process::RunThreadPlan(): try_all_threads was false, we stopped so now we're quitting.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005304 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005305 back_to_top = false;
5306 break;
5307 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005308
Jim Ingham0161b492013-02-09 01:29:05 +00005309 if (before_first_timeout)
5310 {
5311 // Set all the other threads to run, and return to the top of the loop, which will continue;
5312 before_first_timeout = false;
5313 thread_plan_sp->SetStopOthers (false);
5314 if (log)
5315 log->PutCString ("Process::RunThreadPlan(): about to resume.");
Sean Callanana46ec452012-07-11 21:31:24 +00005316
Jim Ingham0161b492013-02-09 01:29:05 +00005317 back_to_top = true;
5318 break;
5319 }
5320 else
5321 {
5322 // Running all threads failed, so return Interrupted.
5323 if (log)
5324 log->PutCString("Process::RunThreadPlan(): running all threads timed out.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005325 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005326 back_to_top = false;
5327 break;
5328 }
Sean Callanana46ec452012-07-11 21:31:24 +00005329 }
5330 }
5331 else
Jim Ingham0161b492013-02-09 01:29:05 +00005332 { if (log)
5333 log->PutCString("Process::RunThreadPlan(): halt said it succeeded, but I got no event. "
5334 "I'm getting out of here passing Interrupted.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005335 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005336 back_to_top = false;
5337 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005338 }
5339 }
Jim Ingham0161b492013-02-09 01:29:05 +00005340 else
5341 {
5342 try_halt_again++;
5343 continue;
5344 }
Sean Callanana46ec452012-07-11 21:31:24 +00005345 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005346
Jim Ingham0161b492013-02-09 01:29:05 +00005347 if (!back_to_top || try_halt_again > num_retries)
5348 break;
5349 else
5350 continue;
Sean Callanana46ec452012-07-11 21:31:24 +00005351 }
Sean Callanana46ec452012-07-11 21:31:24 +00005352 } // END WAIT LOOP
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005353
Sean Callanana46ec452012-07-11 21:31:24 +00005354 // If we had to start up a temporary private state thread to run this thread plan, shut it down now.
5355 if (IS_VALID_LLDB_HOST_THREAD(backup_private_state_thread))
5356 {
5357 StopPrivateStateThread();
5358 Error error;
5359 m_private_state_thread = backup_private_state_thread;
Sean Callanan9a028512012-08-09 00:50:26 +00005360 if (stopper_base_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005361 {
5362 thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
5363 }
5364 m_public_state.SetValueNoLock(old_state);
5365
5366 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005367
Jim Ingham184e9812013-01-15 02:47:48 +00005368 // Restore the thread state if we are going to discard the plan execution. There are three cases where this
5369 // could happen:
5370 // 1) The execution successfully completed
5371 // 2) We hit a breakpoint, and ignore_breakpoints was true
5372 // 3) We got some other error, and discard_on_error was true
Jim Ingham8646d3c2014-05-05 02:47:44 +00005373 bool should_unwind = (return_value == eExpressionInterrupted && options.DoesUnwindOnError())
5374 || (return_value == eExpressionHitBreakpoint && options.DoesIgnoreBreakpoints());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005375
Jim Ingham8646d3c2014-05-05 02:47:44 +00005376 if (return_value == eExpressionCompleted
Jim Ingham184e9812013-01-15 02:47:48 +00005377 || should_unwind)
Jim Ingham8559a352012-11-26 23:52:18 +00005378 {
5379 thread_plan_sp->RestoreThreadState();
5380 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005381
Sean Callanana46ec452012-07-11 21:31:24 +00005382 // Now do some processing on the results of the run:
Jim Ingham8646d3c2014-05-05 02:47:44 +00005383 if (return_value == eExpressionInterrupted || return_value == eExpressionHitBreakpoint)
Sean Callanana46ec452012-07-11 21:31:24 +00005384 {
5385 if (log)
5386 {
5387 StreamString s;
5388 if (event_sp)
5389 event_sp->Dump (&s);
5390 else
5391 {
5392 log->PutCString ("Process::RunThreadPlan(): Stop event that interrupted us is NULL.");
5393 }
5394
5395 StreamString ts;
5396
5397 const char *event_explanation = NULL;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005398
Sean Callanana46ec452012-07-11 21:31:24 +00005399 do
5400 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005401 if (!event_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005402 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005403 event_explanation = "<no event>";
Sean Callanana46ec452012-07-11 21:31:24 +00005404 break;
5405 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005406 else if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005407 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005408 event_explanation = "<user interrupt>";
Sean Callanana46ec452012-07-11 21:31:24 +00005409 break;
5410 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005411 else
Sean Callanana46ec452012-07-11 21:31:24 +00005412 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005413 const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get());
5414
5415 if (!event_data)
Sean Callanana46ec452012-07-11 21:31:24 +00005416 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005417 event_explanation = "<no event data>";
5418 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005419 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005420
Jim Inghamcfc09352012-07-27 23:57:19 +00005421 Process *process = event_data->GetProcessSP().get();
5422
5423 if (!process)
Sean Callanana46ec452012-07-11 21:31:24 +00005424 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005425 event_explanation = "<no process>";
5426 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005427 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005428
Jim Inghamcfc09352012-07-27 23:57:19 +00005429 ThreadList &thread_list = process->GetThreadList();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005430
Jim Inghamcfc09352012-07-27 23:57:19 +00005431 uint32_t num_threads = thread_list.GetSize();
5432 uint32_t thread_index;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005433
Jim Inghamcfc09352012-07-27 23:57:19 +00005434 ts.Printf("<%u threads> ", num_threads);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005435
Jim Inghamcfc09352012-07-27 23:57:19 +00005436 for (thread_index = 0;
5437 thread_index < num_threads;
5438 ++thread_index)
5439 {
5440 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005441
Jim Inghamcfc09352012-07-27 23:57:19 +00005442 if (!thread)
5443 {
5444 ts.Printf("<?> ");
5445 continue;
5446 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005447
Daniel Malead01b2952012-11-29 21:49:15 +00005448 ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00005449 RegisterContext *register_context = thread->GetRegisterContext().get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005450
Jim Inghamcfc09352012-07-27 23:57:19 +00005451 if (register_context)
Daniel Malead01b2952012-11-29 21:49:15 +00005452 ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
Jim Inghamcfc09352012-07-27 23:57:19 +00005453 else
5454 ts.Printf("[ip unknown] ");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005455
Jim Inghamcfc09352012-07-27 23:57:19 +00005456 lldb::StopInfoSP stop_info_sp = thread->GetStopInfo();
5457 if (stop_info_sp)
5458 {
5459 const char *stop_desc = stop_info_sp->GetDescription();
5460 if (stop_desc)
5461 ts.PutCString (stop_desc);
5462 }
5463 ts.Printf(">");
5464 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005465
Jim Inghamcfc09352012-07-27 23:57:19 +00005466 event_explanation = ts.GetData();
Sean Callanana46ec452012-07-11 21:31:24 +00005467 }
Sean Callanana46ec452012-07-11 21:31:24 +00005468 } while (0);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005469
Jim Inghamcfc09352012-07-27 23:57:19 +00005470 if (event_explanation)
5471 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation);
Sean Callanana46ec452012-07-11 21:31:24 +00005472 else
Jim Inghamcfc09352012-07-27 23:57:19 +00005473 log->Printf("Process::RunThreadPlan(): execution interrupted: %s", s.GetData());
5474 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005475
Jim Inghame4483cf2013-09-27 01:13:01 +00005476 if (should_unwind)
Jim Inghamcfc09352012-07-27 23:57:19 +00005477 {
5478 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005479 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - discarding thread plans up to %p.",
5480 static_cast<void*>(thread_plan_sp.get()));
Jim Inghamcfc09352012-07-27 23:57:19 +00005481 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
5482 thread_plan_sp->SetPrivate (orig_plan_private);
5483 }
5484 else
5485 {
5486 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005487 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - for plan: %p not discarding.",
5488 static_cast<void*>(thread_plan_sp.get()));
Sean Callanana46ec452012-07-11 21:31:24 +00005489 }
5490 }
Jim Ingham8646d3c2014-05-05 02:47:44 +00005491 else if (return_value == eExpressionSetupError)
Sean Callanana46ec452012-07-11 21:31:24 +00005492 {
5493 if (log)
5494 log->PutCString("Process::RunThreadPlan(): execution set up error.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005495
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005496 if (options.DoesUnwindOnError())
Jim Ingham0f16e732011-02-08 05:20:59 +00005497 {
Greg Claytonc14ee322011-09-22 04:58:26 +00005498 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Ingham4b536182011-08-09 02:12:22 +00005499 thread_plan_sp->SetPrivate (orig_plan_private);
Jim Ingham0f16e732011-02-08 05:20:59 +00005500 }
Jim Inghamf48169b2010-11-30 02:22:11 +00005501 }
5502 else
5503 {
Sean Callanana46ec452012-07-11 21:31:24 +00005504 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
Jim Inghamf48169b2010-11-30 02:22:11 +00005505 {
Jim Ingham0f16e732011-02-08 05:20:59 +00005506 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00005507 log->PutCString("Process::RunThreadPlan(): thread plan is done");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005508 return_value = eExpressionCompleted;
Sean Callanana46ec452012-07-11 21:31:24 +00005509 }
5510 else if (thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
5511 {
5512 if (log)
5513 log->PutCString("Process::RunThreadPlan(): thread plan was discarded");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005514 return_value = eExpressionDiscarded;
Sean Callanana46ec452012-07-11 21:31:24 +00005515 }
5516 else
5517 {
5518 if (log)
5519 log->PutCString("Process::RunThreadPlan(): thread plan stopped in mid course");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005520 if (options.DoesUnwindOnError() && thread_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005521 {
5522 if (log)
Jim Ingham184e9812013-01-15 02:47:48 +00005523 log->PutCString("Process::RunThreadPlan(): discarding thread plan 'cause unwind_on_error is set.");
Sean Callanana46ec452012-07-11 21:31:24 +00005524 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
5525 thread_plan_sp->SetPrivate (orig_plan_private);
5526 }
5527 }
5528 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005529
Sean Callanana46ec452012-07-11 21:31:24 +00005530 // Thread we ran the function in may have gone away because we ran the target
5531 // Check that it's still there, and if it is put it back in the context. Also restore the
5532 // frame in the context if it is still present.
5533 thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
5534 if (thread)
5535 {
5536 exe_ctx.SetFrameSP (thread->GetFrameWithStackID (ctx_frame_id));
5537 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005538
Sean Callanana46ec452012-07-11 21:31:24 +00005539 // Also restore the current process'es selected frame & thread, since this function calling may
5540 // be done behind the user's back.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005541
Sean Callanana46ec452012-07-11 21:31:24 +00005542 if (selected_tid != LLDB_INVALID_THREAD_ID)
5543 {
5544 if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid())
5545 {
5546 // We were able to restore the selected thread, now restore the frame:
Daniel Maleaa012d3a2013-07-31 20:21:20 +00005547 Mutex::Locker lock(GetThreadList().GetMutex());
Jason Molendab57e4a12013-11-04 09:33:30 +00005548 StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
Sean Callanana46ec452012-07-11 21:31:24 +00005549 if (old_frame_sp)
5550 GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
Jim Inghamf48169b2010-11-30 02:22:11 +00005551 }
Jim Inghamf48169b2010-11-30 02:22:11 +00005552 }
5553 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005554
Sean Callanana46ec452012-07-11 21:31:24 +00005555 // If the process exited during the run of the thread plan, notify everyone.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005556
Sean Callanana46ec452012-07-11 21:31:24 +00005557 if (event_to_broadcast_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00005558 {
Sean Callanana46ec452012-07-11 21:31:24 +00005559 if (log)
5560 log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
5561 BroadcastEvent(event_to_broadcast_sp);
Jim Inghamf48169b2010-11-30 02:22:11 +00005562 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005563
Jim Inghamf48169b2010-11-30 02:22:11 +00005564 return return_value;
5565}
5566
5567const char *
Jim Ingham1624a2d2014-05-05 02:26:40 +00005568Process::ExecutionResultAsCString (ExpressionResults result)
Jim Inghamf48169b2010-11-30 02:22:11 +00005569{
5570 const char *result_name;
5571
5572 switch (result)
5573 {
Jim Ingham8646d3c2014-05-05 02:47:44 +00005574 case eExpressionCompleted:
5575 result_name = "eExpressionCompleted";
Jim Inghamf48169b2010-11-30 02:22:11 +00005576 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005577 case eExpressionDiscarded:
5578 result_name = "eExpressionDiscarded";
Jim Inghamf48169b2010-11-30 02:22:11 +00005579 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005580 case eExpressionInterrupted:
5581 result_name = "eExpressionInterrupted";
Jim Inghamf48169b2010-11-30 02:22:11 +00005582 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005583 case eExpressionHitBreakpoint:
5584 result_name = "eExpressionHitBreakpoint";
Jim Ingham184e9812013-01-15 02:47:48 +00005585 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005586 case eExpressionSetupError:
5587 result_name = "eExpressionSetupError";
Jim Inghamf48169b2010-11-30 02:22:11 +00005588 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005589 case eExpressionParseError:
5590 result_name = "eExpressionParseError";
Jim Ingham1624a2d2014-05-05 02:26:40 +00005591 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005592 case eExpressionResultUnavailable:
5593 result_name = "eExpressionResultUnavailable";
Jim Ingham1624a2d2014-05-05 02:26:40 +00005594 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005595 case eExpressionTimedOut:
5596 result_name = "eExpressionTimedOut";
Jim Inghamf48169b2010-11-30 02:22:11 +00005597 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005598 case eExpressionStoppedForDebug:
5599 result_name = "eExpressionStoppedForDebug";
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005600 break;
Jim Inghamf48169b2010-11-30 02:22:11 +00005601 }
5602 return result_name;
5603}
5604
Greg Clayton7260f622011-04-18 08:33:37 +00005605void
5606Process::GetStatus (Stream &strm)
5607{
5608 const StateType state = GetState();
Greg Clayton2637f822011-11-17 01:23:07 +00005609 if (StateIsStoppedState(state, false))
Greg Clayton7260f622011-04-18 08:33:37 +00005610 {
5611 if (state == eStateExited)
5612 {
5613 int exit_status = GetExitStatus();
5614 const char *exit_description = GetExitDescription();
Daniel Malead01b2952012-11-29 21:49:15 +00005615 strm.Printf ("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
Greg Clayton7260f622011-04-18 08:33:37 +00005616 GetID(),
5617 exit_status,
5618 exit_status,
5619 exit_description ? exit_description : "");
5620 }
5621 else
5622 {
5623 if (state == eStateConnected)
5624 strm.Printf ("Connected to remote target.\n");
5625 else
Daniel Malead01b2952012-11-29 21:49:15 +00005626 strm.Printf ("Process %" PRIu64 " %s\n", GetID(), StateAsCString (state));
Greg Clayton7260f622011-04-18 08:33:37 +00005627 }
5628 }
5629 else
5630 {
Daniel Malead01b2952012-11-29 21:49:15 +00005631 strm.Printf ("Process %" PRIu64 " is running.\n", GetID());
Greg Clayton7260f622011-04-18 08:33:37 +00005632 }
5633}
5634
5635size_t
5636Process::GetThreadStatus (Stream &strm,
5637 bool only_threads_with_stop_reason,
5638 uint32_t start_frame,
5639 uint32_t num_frames,
5640 uint32_t num_frames_with_source)
5641{
5642 size_t num_thread_infos_dumped = 0;
5643
Jim Ingham4a65fb12014-03-07 11:20:03 +00005644 // You can't hold the thread list lock while calling Thread::GetStatus. That very well might run code (e.g. if we need it
5645 // to get return values or arguments.) For that to work the process has to be able to acquire it. So instead copy the thread
5646 // ID's, and look them up one by one:
5647
5648 uint32_t num_threads;
5649 std::vector<uint32_t> thread_index_array;
5650 //Scope for thread list locker;
5651 {
5652 Mutex::Locker locker (GetThreadList().GetMutex());
5653 ThreadList &curr_thread_list = GetThreadList();
5654 num_threads = curr_thread_list.GetSize();
5655 uint32_t idx;
5656 thread_index_array.resize(num_threads);
5657 for (idx = 0; idx < num_threads; ++idx)
5658 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetID();
5659 }
5660
Greg Clayton7260f622011-04-18 08:33:37 +00005661 for (uint32_t i = 0; i < num_threads; i++)
5662 {
Jim Ingham4a65fb12014-03-07 11:20:03 +00005663 ThreadSP thread_sp(GetThreadList().FindThreadByID(thread_index_array[i]));
5664 if (thread_sp)
Greg Clayton7260f622011-04-18 08:33:37 +00005665 {
5666 if (only_threads_with_stop_reason)
5667 {
Jim Ingham4a65fb12014-03-07 11:20:03 +00005668 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
Jim Ingham5d88a062012-10-16 00:09:33 +00005669 if (stop_info_sp.get() == NULL || !stop_info_sp->IsValid())
Greg Clayton7260f622011-04-18 08:33:37 +00005670 continue;
5671 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00005672 thread_sp->GetStatus (strm,
Greg Clayton7260f622011-04-18 08:33:37 +00005673 start_frame,
5674 num_frames,
5675 num_frames_with_source);
5676 ++num_thread_infos_dumped;
5677 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00005678 else
5679 {
5680 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
5681 if (log)
5682 log->Printf("Process::GetThreadStatus - thread 0x" PRIu64 " vanished while running Thread::GetStatus.");
5683
5684 }
Greg Clayton7260f622011-04-18 08:33:37 +00005685 }
5686 return num_thread_infos_dumped;
5687}
5688
Greg Claytona9f40ad2012-02-22 04:37:26 +00005689void
5690Process::AddInvalidMemoryRegion (const LoadRange &region)
5691{
5692 m_memory_cache.AddInvalidRange(region.GetRangeBase(), region.GetByteSize());
5693}
5694
5695bool
5696Process::RemoveInvalidMemoryRange (const LoadRange &region)
5697{
5698 return m_memory_cache.RemoveInvalidRange(region.GetRangeBase(), region.GetByteSize());
5699}
5700
Jim Ingham372787f2012-04-07 00:00:41 +00005701void
5702Process::AddPreResumeAction (PreResumeActionCallback callback, void *baton)
5703{
5704 m_pre_resume_actions.push_back(PreResumeCallbackAndBaton (callback, baton));
5705}
5706
5707bool
5708Process::RunPreResumeActions ()
5709{
5710 bool result = true;
5711 while (!m_pre_resume_actions.empty())
5712 {
5713 struct PreResumeCallbackAndBaton action = m_pre_resume_actions.back();
5714 m_pre_resume_actions.pop_back();
5715 bool this_result = action.callback (action.baton);
5716 if (result == true) result = this_result;
5717 }
5718 return result;
5719}
5720
5721void
5722Process::ClearPreResumeActions ()
5723{
5724 m_pre_resume_actions.clear();
5725}
Greg Claytona9f40ad2012-02-22 04:37:26 +00005726
Greg Claytonfa559e52012-05-18 02:38:05 +00005727void
5728Process::Flush ()
5729{
5730 m_thread_list.Flush();
Jason Molenda5e8dce42013-12-13 00:29:16 +00005731 m_extended_thread_list.Flush();
5732 m_extended_thread_stop_id = 0;
5733 m_queue_list.Clear();
5734 m_queue_list_stop_id = 0;
Greg Claytonfa559e52012-05-18 02:38:05 +00005735}
Greg Clayton90ba8112012-12-05 00:16:59 +00005736
5737void
5738Process::DidExec ()
5739{
5740 Target &target = GetTarget();
5741 target.CleanupProcess ();
Greg Claytonb35db632013-11-09 00:03:31 +00005742 target.ClearModules(false);
Greg Clayton90ba8112012-12-05 00:16:59 +00005743 m_dynamic_checkers_ap.reset();
5744 m_abi_sp.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00005745 m_system_runtime_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00005746 m_os_ap.reset();
Greg Clayton15fc2be2013-05-21 01:00:52 +00005747 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00005748 m_jit_loaders_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00005749 m_image_tokens.clear();
5750 m_allocated_memory_cache.Clear();
5751 m_language_runtimes.clear();
Greg Clayton15fc2be2013-05-21 01:00:52 +00005752 m_thread_list.DiscardThreadPlans();
Greg Clayton15fc2be2013-05-21 01:00:52 +00005753 m_memory_cache.Clear(true);
Greg Clayton90ba8112012-12-05 00:16:59 +00005754 DoDidExec();
5755 CompleteAttach ();
Greg Clayton095eeaa2013-11-05 23:28:00 +00005756 // Flush the process (threads and all stack frames) after running CompleteAttach()
5757 // in case the dynamic loader loaded things in new locations.
5758 Flush();
Greg Claytonb35db632013-11-09 00:03:31 +00005759
5760 // After we figure out what was loaded/unloaded in CompleteAttach,
5761 // we need to let the target know so it can do any cleanup it needs to.
5762 target.DidExec();
Greg Clayton90ba8112012-12-05 00:16:59 +00005763}
Greg Clayton095eeaa2013-11-05 23:28:00 +00005764
Jim Ingham1460e4b2014-01-10 23:46:59 +00005765addr_t
5766Process::ResolveIndirectFunction(const Address *address, Error &error)
5767{
5768 if (address == nullptr)
5769 {
Jean-Daniel Dupasef37711f2014-02-08 20:22:05 +00005770 error.SetErrorString("Invalid address argument");
Jim Ingham1460e4b2014-01-10 23:46:59 +00005771 return LLDB_INVALID_ADDRESS;
5772 }
5773
5774 addr_t function_addr = LLDB_INVALID_ADDRESS;
5775
5776 addr_t addr = address->GetLoadAddress(&GetTarget());
5777 std::map<addr_t,addr_t>::const_iterator iter = m_resolved_indirect_addresses.find(addr);
5778 if (iter != m_resolved_indirect_addresses.end())
5779 {
5780 function_addr = (*iter).second;
5781 }
5782 else
5783 {
5784 if (!InferiorCall(this, address, function_addr))
5785 {
5786 Symbol *symbol = address->CalculateSymbolContextSymbol();
5787 error.SetErrorStringWithFormat ("Unable to call resolver for indirect function %s",
5788 symbol ? symbol->GetName().AsCString() : "<UNKNOWN>");
5789 function_addr = LLDB_INVALID_ADDRESS;
5790 }
5791 else
5792 {
5793 m_resolved_indirect_addresses.insert(std::pair<addr_t, addr_t>(addr, function_addr));
5794 }
5795 }
5796 return function_addr;
5797}
5798
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00005799void
5800Process::ModulesDidLoad (ModuleList &module_list)
5801{
5802 SystemRuntime *sys_runtime = GetSystemRuntime();
5803 if (sys_runtime)
5804 {
5805 sys_runtime->ModulesDidLoad (module_list);
5806 }
5807
5808 GetJITLoaders().ModulesDidLoad (module_list);
5809}