1 //===-- 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 
10 #include "lldb/Target/Process.h"
11 #include "lldb/Breakpoint/StoppointCallbackContext.h"
12 #include "lldb/Breakpoint/BreakpointLocation.h"
13 #include "lldb/Core/Event.h"
14 #include "lldb/Core/Debugger.h"
15 #include "lldb/Core/Log.h"
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/ModuleSpec.h"
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Core/State.h"
20 #include "lldb/Core/StreamFile.h"
21 #include "lldb/Expression/ClangUserExpression.h"
22 #include "lldb/Expression/IRDynamicChecks.h"
23 #include "lldb/Host/ConnectionFileDescriptor.h"
24 #include "lldb/Host/Host.h"
25 #include "lldb/Host/HostInfo.h"
26 #include "lldb/Host/Pipe.h"
27 #include "lldb/Host/Terminal.h"
28 #include "lldb/Host/ThreadLauncher.h"
29 #include "lldb/Interpreter/CommandInterpreter.h"
30 #include "lldb/Interpreter/OptionValueProperties.h"
31 #include "lldb/Symbol/Function.h"
32 #include "lldb/Symbol/Symbol.h"
33 #include "lldb/Target/ABI.h"
34 #include "lldb/Target/DynamicLoader.h"
35 #include "lldb/Target/InstrumentationRuntime.h"
36 #include "lldb/Target/JITLoader.h"
37 #include "lldb/Target/JITLoaderList.h"
38 #include "lldb/Target/MemoryHistory.h"
39 #include "lldb/Target/MemoryRegionInfo.h"
40 #include "lldb/Target/OperatingSystem.h"
41 #include "lldb/Target/LanguageRuntime.h"
42 #include "lldb/Target/CPPLanguageRuntime.h"
43 #include "lldb/Target/ObjCLanguageRuntime.h"
44 #include "lldb/Target/Platform.h"
45 #include "lldb/Target/RegisterContext.h"
46 #include "lldb/Target/StopInfo.h"
47 #include "lldb/Target/SystemRuntime.h"
48 #include "lldb/Target/Target.h"
49 #include "lldb/Target/TargetList.h"
50 #include "lldb/Target/Thread.h"
51 #include "lldb/Target/ThreadPlan.h"
52 #include "lldb/Target/ThreadPlanBase.h"
53 #include "lldb/Target/UnixSignals.h"
54 #include "lldb/Utility/NameMatches.h"
55 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
56 
57 using namespace lldb;
58 using namespace lldb_private;
59 
60 
61 // Comment out line below to disable memory caching, overriding the process setting
62 // target.process.disable-memory-cache
63 #define ENABLE_MEMORY_CACHING
64 
65 #ifdef ENABLE_MEMORY_CACHING
66 #define DISABLE_MEM_CACHE_DEFAULT false
67 #else
68 #define DISABLE_MEM_CACHE_DEFAULT true
69 #endif
70 
71 class ProcessOptionValueProperties : public OptionValueProperties
72 {
73 public:
74     ProcessOptionValueProperties (const ConstString &name) :
75         OptionValueProperties (name)
76     {
77     }
78 
79     // This constructor is used when creating ProcessOptionValueProperties when it
80     // is part of a new lldb_private::Process instance. It will copy all current
81     // global property values as needed
82     ProcessOptionValueProperties (ProcessProperties *global_properties) :
83         OptionValueProperties(*global_properties->GetValueProperties())
84     {
85     }
86 
87     virtual const Property *
88     GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
89     {
90         // When getting the value for a key from the process options, we will always
91         // try and grab the setting from the current process if there is one. Else we just
92         // use the one from this instance.
93         if (exe_ctx)
94         {
95             Process *process = exe_ctx->GetProcessPtr();
96             if (process)
97             {
98                 ProcessOptionValueProperties *instance_properties = static_cast<ProcessOptionValueProperties *>(process->GetValueProperties().get());
99                 if (this != instance_properties)
100                     return instance_properties->ProtectedGetPropertyAtIndex (idx);
101             }
102         }
103         return ProtectedGetPropertyAtIndex (idx);
104     }
105 };
106 
107 static PropertyDefinition
108 g_properties[] =
109 {
110     { "disable-memory-cache" , OptionValue::eTypeBoolean, false, DISABLE_MEM_CACHE_DEFAULT, NULL, NULL, "Disable reading and caching of memory in fixed-size units." },
111     { "extra-startup-command", OptionValue::eTypeArray  , false, OptionValue::eTypeString, NULL, NULL, "A list containing extra commands understood by the particular process plugin used.  "
112                                                                                                        "For instance, to turn on debugserver logging set this to \"QSetLogging:bitmask=LOG_DEFAULT;\"" },
113     { "ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, breakpoints will be ignored during expression evaluation." },
114     { "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." },
115     { "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." },
116     { "stop-on-sharedlibrary-events" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, stop when a shared library is loaded or unloaded." },
117     { "detach-keeps-stopped" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, detach will attempt to keep the process stopped." },
118     { "memory-cache-line-size" , OptionValue::eTypeUInt64, false, 512, NULL, NULL, "The memory cache line size" },
119     { "optimization-warnings" , OptionValue::eTypeBoolean, false, true, NULL, NULL, "If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected." },
120     {  NULL                  , OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL  }
121 };
122 
123 enum {
124     ePropertyDisableMemCache,
125     ePropertyExtraStartCommand,
126     ePropertyIgnoreBreakpointsInExpressions,
127     ePropertyUnwindOnErrorInExpressions,
128     ePropertyPythonOSPluginPath,
129     ePropertyStopOnSharedLibraryEvents,
130     ePropertyDetachKeepsStopped,
131     ePropertyMemCacheLineSize,
132     ePropertyWarningOptimization
133 };
134 
135 ProcessProperties::ProcessProperties (lldb_private::Process *process) :
136     Properties (),
137     m_process (process) // Can be NULL for global ProcessProperties
138 {
139     if (process == NULL)
140     {
141         // Global process properties, set them up one time
142         m_collection_sp.reset (new ProcessOptionValueProperties(ConstString("process")));
143         m_collection_sp->Initialize(g_properties);
144         m_collection_sp->AppendProperty(ConstString("thread"),
145                                         ConstString("Settings specific to threads."),
146                                         true,
147                                         Thread::GetGlobalProperties()->GetValueProperties());
148     }
149     else
150     {
151         m_collection_sp.reset (new ProcessOptionValueProperties(Process::GetGlobalProperties().get()));
152         m_collection_sp->SetValueChangedCallback(ePropertyPythonOSPluginPath, ProcessProperties::OptionValueChangedCallback, this);
153     }
154 }
155 
156 ProcessProperties::~ProcessProperties()
157 {
158 }
159 
160 void
161 ProcessProperties::OptionValueChangedCallback (void *baton, OptionValue *option_value)
162 {
163     ProcessProperties *properties = (ProcessProperties *)baton;
164     if (properties->m_process)
165         properties->m_process->LoadOperatingSystemPlugin(true);
166 }
167 
168 bool
169 ProcessProperties::GetDisableMemoryCache() const
170 {
171     const uint32_t idx = ePropertyDisableMemCache;
172     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
173 }
174 
175 uint64_t
176 ProcessProperties::GetMemoryCacheLineSize() const
177 {
178     const uint32_t idx = ePropertyMemCacheLineSize;
179     return m_collection_sp->GetPropertyAtIndexAsUInt64 (NULL, idx, g_properties[idx].default_uint_value);
180 }
181 
182 Args
183 ProcessProperties::GetExtraStartupCommands () const
184 {
185     Args args;
186     const uint32_t idx = ePropertyExtraStartCommand;
187     m_collection_sp->GetPropertyAtIndexAsArgs(NULL, idx, args);
188     return args;
189 }
190 
191 void
192 ProcessProperties::SetExtraStartupCommands (const Args &args)
193 {
194     const uint32_t idx = ePropertyExtraStartCommand;
195     m_collection_sp->SetPropertyAtIndexFromArgs(NULL, idx, args);
196 }
197 
198 FileSpec
199 ProcessProperties::GetPythonOSPluginPath () const
200 {
201     const uint32_t idx = ePropertyPythonOSPluginPath;
202     return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx);
203 }
204 
205 void
206 ProcessProperties::SetPythonOSPluginPath (const FileSpec &file)
207 {
208     const uint32_t idx = ePropertyPythonOSPluginPath;
209     m_collection_sp->SetPropertyAtIndexAsFileSpec(NULL, idx, file);
210 }
211 
212 
213 bool
214 ProcessProperties::GetIgnoreBreakpointsInExpressions () const
215 {
216     const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
217     return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
218 }
219 
220 void
221 ProcessProperties::SetIgnoreBreakpointsInExpressions (bool ignore)
222 {
223     const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
224     m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore);
225 }
226 
227 bool
228 ProcessProperties::GetUnwindOnErrorInExpressions () const
229 {
230     const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
231     return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
232 }
233 
234 void
235 ProcessProperties::SetUnwindOnErrorInExpressions (bool ignore)
236 {
237     const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
238     m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore);
239 }
240 
241 bool
242 ProcessProperties::GetStopOnSharedLibraryEvents () const
243 {
244     const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
245     return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
246 }
247 
248 void
249 ProcessProperties::SetStopOnSharedLibraryEvents (bool stop)
250 {
251     const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
252     m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop);
253 }
254 
255 bool
256 ProcessProperties::GetDetachKeepsStopped () const
257 {
258     const uint32_t idx = ePropertyDetachKeepsStopped;
259     return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0);
260 }
261 
262 void
263 ProcessProperties::SetDetachKeepsStopped (bool stop)
264 {
265     const uint32_t idx = ePropertyDetachKeepsStopped;
266     m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop);
267 }
268 
269 bool
270 ProcessProperties::GetWarningsOptimization () const
271 {
272     const uint32_t idx = ePropertyWarningOptimization;
273     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
274 }
275 
276 void
277 ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const
278 {
279     const char *cstr;
280     if (m_pid != LLDB_INVALID_PROCESS_ID)
281         s.Printf ("    pid = %" PRIu64 "\n", m_pid);
282 
283     if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
284         s.Printf (" parent = %" PRIu64 "\n", m_parent_pid);
285 
286     if (m_executable)
287     {
288         s.Printf ("   name = %s\n", m_executable.GetFilename().GetCString());
289         s.PutCString ("   file = ");
290         m_executable.Dump(&s);
291         s.EOL();
292     }
293     const uint32_t argc = m_arguments.GetArgumentCount();
294     if (argc > 0)
295     {
296         for (uint32_t i=0; i<argc; i++)
297         {
298             const char *arg = m_arguments.GetArgumentAtIndex(i);
299             if (i < 10)
300                 s.Printf (" arg[%u] = %s\n", i, arg);
301             else
302                 s.Printf ("arg[%u] = %s\n", i, arg);
303         }
304     }
305 
306     const uint32_t envc = m_environment.GetArgumentCount();
307     if (envc > 0)
308     {
309         for (uint32_t i=0; i<envc; i++)
310         {
311             const char *env = m_environment.GetArgumentAtIndex(i);
312             if (i < 10)
313                 s.Printf (" env[%u] = %s\n", i, env);
314             else
315                 s.Printf ("env[%u] = %s\n", i, env);
316         }
317     }
318 
319     if (m_arch.IsValid())
320         s.Printf ("   arch = %s\n", m_arch.GetTriple().str().c_str());
321 
322     if (m_uid != UINT32_MAX)
323     {
324         cstr = platform->GetUserName (m_uid);
325         s.Printf ("    uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
326     }
327     if (m_gid != UINT32_MAX)
328     {
329         cstr = platform->GetGroupName (m_gid);
330         s.Printf ("    gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
331     }
332     if (m_euid != UINT32_MAX)
333     {
334         cstr = platform->GetUserName (m_euid);
335         s.Printf ("   euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
336     }
337     if (m_egid != UINT32_MAX)
338     {
339         cstr = platform->GetGroupName (m_egid);
340         s.Printf ("   egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
341     }
342 }
343 
344 void
345 ProcessInstanceInfo::DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose)
346 {
347     const char *label;
348     if (show_args || verbose)
349         label = "ARGUMENTS";
350     else
351         label = "NAME";
352 
353     if (verbose)
354     {
355         s.Printf     ("PID    PARENT USER       GROUP      EFF USER   EFF GROUP  TRIPLE                   %s\n", label);
356         s.PutCString ("====== ====== ========== ========== ========== ========== ======================== ============================\n");
357     }
358     else
359     {
360         s.Printf     ("PID    PARENT USER       TRIPLE                   %s\n", label);
361         s.PutCString ("====== ====== ========== ======================== ============================\n");
362     }
363 }
364 
365 void
366 ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const
367 {
368     if (m_pid != LLDB_INVALID_PROCESS_ID)
369     {
370         const char *cstr;
371         s.Printf ("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
372 
373 
374         if (verbose)
375         {
376             cstr = platform->GetUserName (m_uid);
377             if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
378                 s.Printf ("%-10s ", cstr);
379             else
380                 s.Printf ("%-10u ", m_uid);
381 
382             cstr = platform->GetGroupName (m_gid);
383             if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
384                 s.Printf ("%-10s ", cstr);
385             else
386                 s.Printf ("%-10u ", m_gid);
387 
388             cstr = platform->GetUserName (m_euid);
389             if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
390                 s.Printf ("%-10s ", cstr);
391             else
392                 s.Printf ("%-10u ", m_euid);
393 
394             cstr = platform->GetGroupName (m_egid);
395             if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
396                 s.Printf ("%-10s ", cstr);
397             else
398                 s.Printf ("%-10u ", m_egid);
399             s.Printf ("%-24s ", m_arch.IsValid() ? m_arch.GetTriple().str().c_str() : "");
400         }
401         else
402         {
403             s.Printf ("%-10s %-24s ",
404                       platform->GetUserName (m_euid),
405                       m_arch.IsValid() ? m_arch.GetTriple().str().c_str() : "");
406         }
407 
408         if (verbose || show_args)
409         {
410             const uint32_t argc = m_arguments.GetArgumentCount();
411             if (argc > 0)
412             {
413                 for (uint32_t i=0; i<argc; i++)
414                 {
415                     if (i > 0)
416                         s.PutChar (' ');
417                     s.PutCString (m_arguments.GetArgumentAtIndex(i));
418                 }
419             }
420         }
421         else
422         {
423             s.PutCString (GetName());
424         }
425 
426         s.EOL();
427     }
428 }
429 
430 Error
431 ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
432 {
433     Error error;
434     const int short_option = m_getopt_table[option_idx].val;
435 
436     switch (short_option)
437     {
438         case 's':   // Stop at program entry point
439             launch_info.GetFlags().Set (eLaunchFlagStopAtEntry);
440             break;
441 
442         case 'i':   // STDIN for read only
443         {
444             FileAction action;
445             if (action.Open(STDIN_FILENO, FileSpec{option_arg, false}, true, false))
446                 launch_info.AppendFileAction (action);
447             break;
448         }
449 
450         case 'o':   // Open STDOUT for write only
451         {
452             FileAction action;
453             if (action.Open(STDOUT_FILENO, FileSpec{option_arg, false}, false, true))
454                 launch_info.AppendFileAction (action);
455             break;
456         }
457 
458         case 'e':   // STDERR for write only
459         {
460             FileAction action;
461             if (action.Open(STDERR_FILENO, FileSpec{option_arg, false}, false, true))
462                 launch_info.AppendFileAction (action);
463             break;
464         }
465 
466         case 'p':   // Process plug-in name
467             launch_info.SetProcessPluginName (option_arg);
468             break;
469 
470         case 'n':   // Disable STDIO
471         {
472             FileAction action;
473             const FileSpec dev_null{"/dev/null", false};
474             if (action.Open(STDIN_FILENO, dev_null, true, false))
475                 launch_info.AppendFileAction (action);
476             if (action.Open(STDOUT_FILENO, dev_null, false, true))
477                 launch_info.AppendFileAction (action);
478             if (action.Open(STDERR_FILENO, dev_null, false, true))
479                 launch_info.AppendFileAction (action);
480             break;
481         }
482 
483         case 'w':
484             launch_info.SetWorkingDirectory(FileSpec{option_arg, false});
485             break;
486 
487         case 't':   // Open process in new terminal window
488             launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
489             break;
490 
491         case 'a':
492             if (!launch_info.GetArchitecture().SetTriple (option_arg, m_interpreter.GetPlatform(true).get()))
493                 launch_info.GetArchitecture().SetTriple (option_arg);
494             break;
495 
496         case 'A':   // Disable ASLR.
497         {
498             bool success;
499             const bool disable_aslr_arg = Args::StringToBoolean (option_arg, true, &success);
500             if (success)
501                 disable_aslr = disable_aslr_arg ? eLazyBoolYes : eLazyBoolNo;
502             else
503                 error.SetErrorStringWithFormat ("Invalid boolean value for disable-aslr option: '%s'", option_arg ? option_arg : "<null>");
504             break;
505         }
506 
507         case 'X':   // shell expand args.
508         {
509             bool success;
510             const bool expand_args = Args::StringToBoolean (option_arg, true, &success);
511             if (success)
512                 launch_info.SetShellExpandArguments(expand_args);
513             else
514                 error.SetErrorStringWithFormat ("Invalid boolean value for shell-expand-args option: '%s'", option_arg ? option_arg : "<null>");
515             break;
516         }
517 
518         case 'c':
519             if (option_arg && option_arg[0])
520                 launch_info.SetShell (FileSpec(option_arg, false));
521             else
522                 launch_info.SetShell (HostInfo::GetDefaultShell());
523             break;
524 
525         case 'v':
526             launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
527             break;
528 
529         default:
530             error.SetErrorStringWithFormat("unrecognized short option character '%c'", short_option);
531             break;
532     }
533     return error;
534 }
535 
536 OptionDefinition
537 ProcessLaunchCommandOptions::g_option_table[] =
538 {
539 { LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,          "Stop at the entry point of the program when launching a process."},
540 { LLDB_OPT_SET_ALL, false, "disable-aslr",  'A', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,          "Set whether to disable address space layout randomization when launching a process."},
541 { LLDB_OPT_SET_ALL, false, "plugin",        'p', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePlugin,        "Name of the process plugin you want to use."},
542 { LLDB_OPT_SET_ALL, false, "working-dir",   'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeDirectoryName,          "Set the current working directory to <path> when running the inferior."},
543 { LLDB_OPT_SET_ALL, false, "arch",          'a', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeArchitecture,  "Set the architecture for the process to launch when ambiguous."},
544 { LLDB_OPT_SET_ALL, false, "environment",   'v', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeNone,          "Specify an environment variable name/value string (--environment NAME=VALUE). Can be specified multiple times for subsequent environment entries."},
545 { LLDB_OPT_SET_1|LLDB_OPT_SET_2|LLDB_OPT_SET_3, false, "shell",         'c', OptionParser::eOptionalArgument, NULL, NULL, 0, eArgTypeFilename,          "Run the process in a shell (not supported on all platforms)."},
546 
547 { LLDB_OPT_SET_1  , false, "stdin",         'i', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename,    "Redirect stdin for the process to <filename>."},
548 { LLDB_OPT_SET_1  , false, "stdout",        'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename,    "Redirect stdout for the process to <filename>."},
549 { LLDB_OPT_SET_1  , false, "stderr",        'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename,    "Redirect stderr for the process to <filename>."},
550 
551 { LLDB_OPT_SET_2  , false, "tty",           't', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,    "Start the process in a terminal (not supported on all platforms)."},
552 
553 { LLDB_OPT_SET_3  , false, "no-stdio",      'n', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone,    "Do not set up for terminal I/O to go to running process."},
554 { LLDB_OPT_SET_4,   false, "shell-expand-args",       'X', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,          "Set whether to shell expand arguments to the process when launching."},
555 { 0               , false, NULL,             0,  0,                 NULL, NULL, 0, eArgTypeNone,    NULL }
556 };
557 
558 
559 
560 bool
561 ProcessInstanceInfoMatch::NameMatches (const char *process_name) const
562 {
563     if (m_name_match_type == eNameMatchIgnore || process_name == NULL)
564         return true;
565     const char *match_name = m_match_info.GetName();
566     if (!match_name)
567         return true;
568 
569     return lldb_private::NameMatches (process_name, m_name_match_type, match_name);
570 }
571 
572 bool
573 ProcessInstanceInfoMatch::Matches (const ProcessInstanceInfo &proc_info) const
574 {
575     if (!NameMatches (proc_info.GetName()))
576         return false;
577 
578     if (m_match_info.ProcessIDIsValid() &&
579         m_match_info.GetProcessID() != proc_info.GetProcessID())
580         return false;
581 
582     if (m_match_info.ParentProcessIDIsValid() &&
583         m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
584         return false;
585 
586     if (m_match_info.UserIDIsValid () &&
587         m_match_info.GetUserID() != proc_info.GetUserID())
588         return false;
589 
590     if (m_match_info.GroupIDIsValid () &&
591         m_match_info.GetGroupID() != proc_info.GetGroupID())
592         return false;
593 
594     if (m_match_info.EffectiveUserIDIsValid () &&
595         m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
596         return false;
597 
598     if (m_match_info.EffectiveGroupIDIsValid () &&
599         m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
600         return false;
601 
602     if (m_match_info.GetArchitecture().IsValid() &&
603         !m_match_info.GetArchitecture().IsCompatibleMatch(proc_info.GetArchitecture()))
604         return false;
605     return true;
606 }
607 
608 bool
609 ProcessInstanceInfoMatch::MatchAllProcesses () const
610 {
611     if (m_name_match_type != eNameMatchIgnore)
612         return false;
613 
614     if (m_match_info.ProcessIDIsValid())
615         return false;
616 
617     if (m_match_info.ParentProcessIDIsValid())
618         return false;
619 
620     if (m_match_info.UserIDIsValid ())
621         return false;
622 
623     if (m_match_info.GroupIDIsValid ())
624         return false;
625 
626     if (m_match_info.EffectiveUserIDIsValid ())
627         return false;
628 
629     if (m_match_info.EffectiveGroupIDIsValid ())
630         return false;
631 
632     if (m_match_info.GetArchitecture().IsValid())
633         return false;
634 
635     if (m_match_all_users)
636         return false;
637 
638     return true;
639 
640 }
641 
642 void
643 ProcessInstanceInfoMatch::Clear()
644 {
645     m_match_info.Clear();
646     m_name_match_type = eNameMatchIgnore;
647     m_match_all_users = false;
648 }
649 
650 ProcessSP
651 Process::FindPlugin (Target &target, const char *plugin_name, Listener &listener, const FileSpec *crash_file_path)
652 {
653     static uint32_t g_process_unique_id = 0;
654 
655     ProcessSP process_sp;
656     ProcessCreateInstance create_callback = NULL;
657     if (plugin_name)
658     {
659         ConstString const_plugin_name(plugin_name);
660         create_callback  = PluginManager::GetProcessCreateCallbackForPluginName (const_plugin_name);
661         if (create_callback)
662         {
663             process_sp = create_callback(target, listener, crash_file_path);
664             if (process_sp)
665             {
666                 if (process_sp->CanDebug(target, true))
667                 {
668                     process_sp->m_process_unique_id = ++g_process_unique_id;
669                 }
670                 else
671                     process_sp.reset();
672             }
673         }
674     }
675     else
676     {
677         for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx)
678         {
679             process_sp = create_callback(target, listener, crash_file_path);
680             if (process_sp)
681             {
682                 if (process_sp->CanDebug(target, false))
683                 {
684                     process_sp->m_process_unique_id = ++g_process_unique_id;
685                     break;
686                 }
687                 else
688                     process_sp.reset();
689             }
690         }
691     }
692     return process_sp;
693 }
694 
695 ConstString &
696 Process::GetStaticBroadcasterClass ()
697 {
698     static ConstString class_name ("lldb.process");
699     return class_name;
700 }
701 
702 //----------------------------------------------------------------------
703 // Process constructor
704 //----------------------------------------------------------------------
705 Process::Process(Target &target, Listener &listener) :
706     Process(target, listener, UnixSignals::Create(HostInfo::GetArchitecture()))
707 {
708     // This constructor just delegates to the full Process constructor,
709     // defaulting to using the Host's UnixSignals.
710 }
711 
712 Process::Process(Target &target, Listener &listener, const UnixSignalsSP &unix_signals_sp) :
713     ProcessProperties (this),
714     UserID (LLDB_INVALID_PROCESS_ID),
715     Broadcaster (&(target.GetDebugger()), Process::GetStaticBroadcasterClass().AsCString()),
716     m_target (target),
717     m_public_state (eStateUnloaded),
718     m_private_state (eStateUnloaded),
719     m_private_state_broadcaster (NULL, "lldb.process.internal_state_broadcaster"),
720     m_private_state_control_broadcaster (NULL, "lldb.process.internal_state_control_broadcaster"),
721     m_private_state_listener ("lldb.process.internal_state_listener"),
722     m_private_state_control_wait(),
723     m_mod_id (),
724     m_process_unique_id(0),
725     m_thread_index_id (0),
726     m_thread_id_to_index_id_map (),
727     m_exit_status (-1),
728     m_exit_string (),
729     m_exit_status_mutex(),
730     m_thread_mutex (Mutex::eMutexTypeRecursive),
731     m_thread_list_real (this),
732     m_thread_list (this),
733     m_extended_thread_list (this),
734     m_extended_thread_stop_id (0),
735     m_queue_list (this),
736     m_queue_list_stop_id (0),
737     m_notifications (),
738     m_image_tokens (),
739     m_listener (listener),
740     m_breakpoint_site_list (),
741     m_dynamic_checkers_ap (),
742     m_unix_signals_sp (unix_signals_sp),
743     m_abi_sp (),
744     m_process_input_reader (),
745     m_stdio_communication ("process.stdio"),
746     m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
747     m_stdin_forward (false),
748     m_stdout_data (),
749     m_stderr_data (),
750     m_profile_data_comm_mutex (Mutex::eMutexTypeRecursive),
751     m_profile_data (),
752     m_iohandler_sync (0),
753     m_memory_cache (*this),
754     m_allocated_memory_cache (*this),
755     m_should_detach (false),
756     m_next_event_action_ap(),
757     m_public_run_lock (),
758     m_private_run_lock (),
759     m_currently_handling_event(false),
760     m_stop_info_override_callback (NULL),
761     m_finalizing (false),
762     m_finalize_called (false),
763     m_clear_thread_plans_on_stop (false),
764     m_force_next_event_delivery (false),
765     m_last_broadcast_state (eStateInvalid),
766     m_destroy_in_process (false),
767     m_can_interpret_function_calls(false),
768     m_warnings_issued (),
769     m_can_jit(eCanJITDontKnow)
770 {
771     CheckInWithManager ();
772 
773     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
774     if (log)
775         log->Printf ("%p Process::Process()", static_cast<void*>(this));
776 
777     if (!m_unix_signals_sp)
778         m_unix_signals_sp = std::make_shared<UnixSignals>();
779 
780     SetEventName (eBroadcastBitStateChanged, "state-changed");
781     SetEventName (eBroadcastBitInterrupt, "interrupt");
782     SetEventName (eBroadcastBitSTDOUT, "stdout-available");
783     SetEventName (eBroadcastBitSTDERR, "stderr-available");
784     SetEventName (eBroadcastBitProfileData, "profile-data-available");
785 
786     m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlStop  , "control-stop"  );
787     m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlPause , "control-pause" );
788     m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlResume, "control-resume");
789 
790     listener.StartListeningForEvents (this,
791                                       eBroadcastBitStateChanged |
792                                       eBroadcastBitInterrupt |
793                                       eBroadcastBitSTDOUT |
794                                       eBroadcastBitSTDERR |
795                                       eBroadcastBitProfileData);
796 
797     m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster,
798                                                      eBroadcastBitStateChanged |
799                                                      eBroadcastBitInterrupt);
800 
801     m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster,
802                                                      eBroadcastInternalStateControlStop |
803                                                      eBroadcastInternalStateControlPause |
804                                                      eBroadcastInternalStateControlResume);
805     // We need something valid here, even if just the default UnixSignalsSP.
806     assert (m_unix_signals_sp && "null m_unix_signals_sp after initialization");
807 }
808 
809 //----------------------------------------------------------------------
810 // Destructor
811 //----------------------------------------------------------------------
812 Process::~Process()
813 {
814     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
815     if (log)
816         log->Printf ("%p Process::~Process()", static_cast<void*>(this));
817     StopPrivateStateThread();
818 
819     // ThreadList::Clear() will try to acquire this process's mutex, so
820     // explicitly clear the thread list here to ensure that the mutex
821     // is not destroyed before the thread list.
822     m_thread_list.Clear();
823 }
824 
825 const ProcessPropertiesSP &
826 Process::GetGlobalProperties()
827 {
828     static ProcessPropertiesSP g_settings_sp;
829     if (!g_settings_sp)
830         g_settings_sp.reset (new ProcessProperties (NULL));
831     return g_settings_sp;
832 }
833 
834 void
835 Process::Finalize()
836 {
837     m_finalizing = true;
838 
839     // Destroy this process if needed
840     switch (GetPrivateState())
841     {
842         case eStateConnected:
843         case eStateAttaching:
844         case eStateLaunching:
845         case eStateStopped:
846         case eStateRunning:
847         case eStateStepping:
848         case eStateCrashed:
849         case eStateSuspended:
850             Destroy(false);
851             break;
852 
853         case eStateInvalid:
854         case eStateUnloaded:
855         case eStateDetached:
856         case eStateExited:
857             break;
858     }
859 
860     // Clear our broadcaster before we proceed with destroying
861     Broadcaster::Clear();
862 
863     // Do any cleanup needed prior to being destructed... Subclasses
864     // that override this method should call this superclass method as well.
865 
866     // We need to destroy the loader before the derived Process class gets destroyed
867     // since it is very likely that undoing the loader will require access to the real process.
868     m_dynamic_checkers_ap.reset();
869     m_abi_sp.reset();
870     m_os_ap.reset();
871     m_system_runtime_ap.reset();
872     m_dyld_ap.reset();
873     m_jit_loaders_ap.reset();
874     m_thread_list_real.Destroy();
875     m_thread_list.Destroy();
876     m_extended_thread_list.Destroy();
877     m_queue_list.Clear();
878     m_queue_list_stop_id = 0;
879     std::vector<Notifications> empty_notifications;
880     m_notifications.swap(empty_notifications);
881     m_image_tokens.clear();
882     m_memory_cache.Clear();
883     m_allocated_memory_cache.Clear();
884     m_language_runtimes.clear();
885     m_instrumentation_runtimes.clear();
886     m_next_event_action_ap.reset();
887     m_stop_info_override_callback = NULL;
888     // Clear the last natural stop ID since it has a strong
889     // reference to this process
890     m_mod_id.SetStopEventForLastNaturalStopID(EventSP());
891 //#ifdef LLDB_CONFIGURATION_DEBUG
892 //    StreamFile s(stdout, false);
893 //    EventSP event_sp;
894 //    while (m_private_state_listener.GetNextEvent(event_sp))
895 //    {
896 //        event_sp->Dump (&s);
897 //        s.EOL();
898 //    }
899 //#endif
900     // We have to be very careful here as the m_private_state_listener might
901     // contain events that have ProcessSP values in them which can keep this
902     // process around forever. These events need to be cleared out.
903     m_private_state_listener.Clear();
904     m_public_run_lock.TrySetRunning(); // This will do nothing if already locked
905     m_public_run_lock.SetStopped();
906     m_private_run_lock.TrySetRunning(); // This will do nothing if already locked
907     m_private_run_lock.SetStopped();
908     m_finalize_called = true;
909 }
910 
911 void
912 Process::RegisterNotificationCallbacks (const Notifications& callbacks)
913 {
914     m_notifications.push_back(callbacks);
915     if (callbacks.initialize != NULL)
916         callbacks.initialize (callbacks.baton, this);
917 }
918 
919 bool
920 Process::UnregisterNotificationCallbacks(const Notifications& callbacks)
921 {
922     std::vector<Notifications>::iterator pos, end = m_notifications.end();
923     for (pos = m_notifications.begin(); pos != end; ++pos)
924     {
925         if (pos->baton == callbacks.baton &&
926             pos->initialize == callbacks.initialize &&
927             pos->process_state_changed == callbacks.process_state_changed)
928         {
929             m_notifications.erase(pos);
930             return true;
931         }
932     }
933     return false;
934 }
935 
936 void
937 Process::SynchronouslyNotifyStateChanged (StateType state)
938 {
939     std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end();
940     for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos)
941     {
942         if (notification_pos->process_state_changed)
943             notification_pos->process_state_changed (notification_pos->baton, this, state);
944     }
945 }
946 
947 // FIXME: We need to do some work on events before the general Listener sees them.
948 // For instance if we are continuing from a breakpoint, we need to ensure that we do
949 // the little "insert real insn, step & stop" trick.  But we can't do that when the
950 // event is delivered by the broadcaster - since that is done on the thread that is
951 // waiting for new events, so if we needed more than one event for our handling, we would
952 // stall.  So instead we do it when we fetch the event off of the queue.
953 //
954 
955 StateType
956 Process::GetNextEvent (EventSP &event_sp)
957 {
958     StateType state = eStateInvalid;
959 
960     if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp)
961         state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
962 
963     return state;
964 }
965 
966 void
967 Process::SyncIOHandler (uint32_t iohandler_id, uint64_t timeout_msec)
968 {
969     // don't sync (potentially context switch) in case where there is no process IO
970     if (! m_process_input_reader)
971         return;
972 
973     TimeValue timeout = TimeValue::Now();
974     timeout.OffsetWithMicroSeconds(timeout_msec*1000);
975     uint32_t new_iohandler_id = 0;
976     m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id, new_iohandler_id, &timeout);
977 
978     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
979     if (log)
980         log->Printf("Process::%s waited for m_iohandler_sync to change from %u, new value is %u", __FUNCTION__, iohandler_id, new_iohandler_id);
981 }
982 
983 StateType
984 Process::WaitForProcessToStop (const TimeValue *timeout,
985                                EventSP *event_sp_ptr,
986                                bool wait_always,
987                                Listener *hijack_listener,
988                                Stream *stream)
989 {
990     // We can't just wait for a "stopped" event, because the stopped event may have restarted the target.
991     // We have to actually check each event, and in the case of a stopped event check the restarted flag
992     // on the event.
993     if (event_sp_ptr)
994         event_sp_ptr->reset();
995     StateType state = GetState();
996     // If we are exited or detached, we won't ever get back to any
997     // other valid state...
998     if (state == eStateDetached || state == eStateExited)
999         return state;
1000 
1001     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1002     if (log)
1003         log->Printf ("Process::%s (timeout = %p)", __FUNCTION__,
1004                      static_cast<const void*>(timeout));
1005 
1006     if (!wait_always &&
1007         StateIsStoppedState(state, true) &&
1008         StateIsStoppedState(GetPrivateState(), true))
1009     {
1010         if (log)
1011             log->Printf("Process::%s returning without waiting for events; process private and public states are already 'stopped'.",
1012                         __FUNCTION__);
1013         // We need to toggle the run lock as this won't get done in
1014         // SetPublicState() if the process is hijacked.
1015         if (hijack_listener)
1016             m_public_run_lock.SetStopped();
1017         return state;
1018     }
1019 
1020     while (state != eStateInvalid)
1021     {
1022         EventSP event_sp;
1023         state = WaitForStateChangedEvents (timeout, event_sp, hijack_listener);
1024         if (event_sp_ptr && event_sp)
1025             *event_sp_ptr = event_sp;
1026 
1027         bool pop_process_io_handler = hijack_listener != NULL;
1028         Process::HandleProcessStateChangedEvent (event_sp, stream, pop_process_io_handler);
1029 
1030         switch (state)
1031         {
1032         case eStateCrashed:
1033         case eStateDetached:
1034         case eStateExited:
1035         case eStateUnloaded:
1036             // We need to toggle the run lock as this won't get done in
1037             // SetPublicState() if the process is hijacked.
1038             if (hijack_listener)
1039                 m_public_run_lock.SetStopped();
1040             return state;
1041         case eStateStopped:
1042             if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
1043                 continue;
1044             else
1045             {
1046                 // We need to toggle the run lock as this won't get done in
1047                 // SetPublicState() if the process is hijacked.
1048                 if (hijack_listener)
1049                     m_public_run_lock.SetStopped();
1050                 return state;
1051             }
1052         default:
1053             continue;
1054         }
1055     }
1056     return state;
1057 }
1058 
1059 bool
1060 Process::HandleProcessStateChangedEvent (const EventSP &event_sp,
1061                                          Stream *stream,
1062                                          bool &pop_process_io_handler)
1063 {
1064     const bool handle_pop = pop_process_io_handler == true;
1065 
1066     pop_process_io_handler = false;
1067     ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
1068 
1069     if (!process_sp)
1070         return false;
1071 
1072     StateType event_state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
1073     if (event_state == eStateInvalid)
1074         return false;
1075 
1076     switch (event_state)
1077     {
1078         case eStateInvalid:
1079         case eStateUnloaded:
1080         case eStateAttaching:
1081         case eStateLaunching:
1082         case eStateStepping:
1083         case eStateDetached:
1084             {
1085                 if (stream)
1086                     stream->Printf ("Process %" PRIu64 " %s\n",
1087                                     process_sp->GetID(),
1088                                     StateAsCString (event_state));
1089 
1090                 if (event_state == eStateDetached)
1091                     pop_process_io_handler = true;
1092             }
1093             break;
1094 
1095         case eStateConnected:
1096         case eStateRunning:
1097             // Don't be chatty when we run...
1098             break;
1099 
1100         case eStateExited:
1101             if (stream)
1102                 process_sp->GetStatus(*stream);
1103             pop_process_io_handler = true;
1104             break;
1105 
1106         case eStateStopped:
1107         case eStateCrashed:
1108         case eStateSuspended:
1109             // Make sure the program hasn't been auto-restarted:
1110             if (Process::ProcessEventData::GetRestartedFromEvent (event_sp.get()))
1111             {
1112                 if (stream)
1113                 {
1114                     size_t num_reasons = Process::ProcessEventData::GetNumRestartedReasons(event_sp.get());
1115                     if (num_reasons > 0)
1116                     {
1117                         // FIXME: Do we want to report this, or would that just be annoyingly chatty?
1118                         if (num_reasons == 1)
1119                         {
1120                             const char *reason = Process::ProcessEventData::GetRestartedReasonAtIndex (event_sp.get(), 0);
1121                             stream->Printf ("Process %" PRIu64 " stopped and restarted: %s\n",
1122                                             process_sp->GetID(),
1123                                             reason ? reason : "<UNKNOWN REASON>");
1124                         }
1125                         else
1126                         {
1127                             stream->Printf ("Process %" PRIu64 " stopped and restarted, reasons:\n",
1128                                             process_sp->GetID());
1129 
1130 
1131                             for (size_t i = 0; i < num_reasons; i++)
1132                             {
1133                                 const char *reason = Process::ProcessEventData::GetRestartedReasonAtIndex (event_sp.get(), i);
1134                                 stream->Printf("\t%s\n", reason ? reason : "<UNKNOWN REASON>");
1135                             }
1136                         }
1137                     }
1138                 }
1139             }
1140             else
1141             {
1142                 // Lock the thread list so it doesn't change on us, this is the scope for the locker:
1143                 {
1144                     ThreadList &thread_list = process_sp->GetThreadList();
1145                     Mutex::Locker locker (thread_list.GetMutex());
1146 
1147                     ThreadSP curr_thread (thread_list.GetSelectedThread());
1148                     ThreadSP thread;
1149                     StopReason curr_thread_stop_reason = eStopReasonInvalid;
1150                     if (curr_thread)
1151                         curr_thread_stop_reason = curr_thread->GetStopReason();
1152                     if (!curr_thread ||
1153                         !curr_thread->IsValid() ||
1154                         curr_thread_stop_reason == eStopReasonInvalid ||
1155                         curr_thread_stop_reason == eStopReasonNone)
1156                     {
1157                         // Prefer a thread that has just completed its plan over another thread as current thread.
1158                         ThreadSP plan_thread;
1159                         ThreadSP other_thread;
1160 
1161                         const size_t num_threads = thread_list.GetSize();
1162                         size_t i;
1163                         for (i = 0; i < num_threads; ++i)
1164                         {
1165                             thread = thread_list.GetThreadAtIndex(i);
1166                             StopReason thread_stop_reason = thread->GetStopReason();
1167                             switch (thread_stop_reason)
1168                             {
1169                                 case eStopReasonInvalid:
1170                                 case eStopReasonNone:
1171                                     break;
1172 
1173                                  case eStopReasonSignal:
1174                                 {
1175                                     // Don't select a signal thread if we weren't going to stop at that
1176                                     // signal.  We have to have had another reason for stopping here, and
1177                                     // the user doesn't want to see this thread.
1178                                     uint64_t signo = thread->GetStopInfo()->GetValue();
1179                                     if (process_sp->GetUnixSignals()->GetShouldStop(signo))
1180                                     {
1181                                         if (!other_thread)
1182                                             other_thread = thread;
1183                                     }
1184                                     break;
1185                                 }
1186                                 case eStopReasonTrace:
1187                                 case eStopReasonBreakpoint:
1188                                 case eStopReasonWatchpoint:
1189                                 case eStopReasonException:
1190                                 case eStopReasonExec:
1191                                 case eStopReasonThreadExiting:
1192                                 case eStopReasonInstrumentation:
1193                                     if (!other_thread)
1194                                         other_thread = thread;
1195                                     break;
1196                                 case eStopReasonPlanComplete:
1197                                     if (!plan_thread)
1198                                         plan_thread = thread;
1199                                     break;
1200                             }
1201                         }
1202                         if (plan_thread)
1203                             thread_list.SetSelectedThreadByID (plan_thread->GetID());
1204                         else if (other_thread)
1205                             thread_list.SetSelectedThreadByID (other_thread->GetID());
1206                         else
1207                         {
1208                             if (curr_thread && curr_thread->IsValid())
1209                                 thread = curr_thread;
1210                             else
1211                                 thread = thread_list.GetThreadAtIndex(0);
1212 
1213                             if (thread)
1214                                 thread_list.SetSelectedThreadByID (thread->GetID());
1215                         }
1216                     }
1217                 }
1218                 // Drop the ThreadList mutex by here, since GetThreadStatus below might have to run code,
1219                 // e.g. for Data formatters, and if we hold the ThreadList mutex, then the process is going to
1220                 // have a hard time restarting the process.
1221                 if (stream)
1222                 {
1223                     Debugger &debugger = process_sp->GetTarget().GetDebugger();
1224                     if (debugger.GetTargetList().GetSelectedTarget().get() == &process_sp->GetTarget())
1225                     {
1226                         const bool only_threads_with_stop_reason = true;
1227                         const uint32_t start_frame = 0;
1228                         const uint32_t num_frames = 1;
1229                         const uint32_t num_frames_with_source = 1;
1230                         process_sp->GetStatus(*stream);
1231                         process_sp->GetThreadStatus (*stream,
1232                                                      only_threads_with_stop_reason,
1233                                                      start_frame,
1234                                                      num_frames,
1235                                                      num_frames_with_source);
1236                     }
1237                     else
1238                     {
1239                         uint32_t target_idx = debugger.GetTargetList().GetIndexOfTarget(process_sp->GetTarget().shared_from_this());
1240                         if (target_idx != UINT32_MAX)
1241                             stream->Printf ("Target %d: (", target_idx);
1242                         else
1243                             stream->Printf ("Target <unknown index>: (");
1244                         process_sp->GetTarget().Dump (stream, eDescriptionLevelBrief);
1245                         stream->Printf (") stopped.\n");
1246                     }
1247                 }
1248 
1249                 // Pop the process IO handler
1250                 pop_process_io_handler = true;
1251             }
1252             break;
1253     }
1254 
1255     if (handle_pop && pop_process_io_handler)
1256         process_sp->PopProcessIOHandler();
1257 
1258     return true;
1259 }
1260 
1261 
1262 StateType
1263 Process::WaitForState
1264 (
1265     const TimeValue *timeout,
1266     const StateType *match_states,
1267     const uint32_t num_match_states
1268 )
1269 {
1270     EventSP event_sp;
1271     uint32_t i;
1272     StateType state = GetState();
1273     while (state != eStateInvalid)
1274     {
1275         // If we are exited or detached, we won't ever get back to any
1276         // other valid state...
1277         if (state == eStateDetached || state == eStateExited)
1278             return state;
1279 
1280         state = WaitForStateChangedEvents (timeout, event_sp, NULL);
1281 
1282         for (i=0; i<num_match_states; ++i)
1283         {
1284             if (match_states[i] == state)
1285                 return state;
1286         }
1287     }
1288     return state;
1289 }
1290 
1291 bool
1292 Process::HijackProcessEvents (Listener *listener)
1293 {
1294     if (listener != NULL)
1295     {
1296         return HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt);
1297     }
1298     else
1299         return false;
1300 }
1301 
1302 void
1303 Process::RestoreProcessEvents ()
1304 {
1305     RestoreBroadcaster();
1306 }
1307 
1308 bool
1309 Process::HijackPrivateProcessEvents (Listener *listener)
1310 {
1311     if (listener != NULL)
1312     {
1313         return m_private_state_broadcaster.HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt);
1314     }
1315     else
1316         return false;
1317 }
1318 
1319 void
1320 Process::RestorePrivateProcessEvents ()
1321 {
1322     m_private_state_broadcaster.RestoreBroadcaster();
1323 }
1324 
1325 StateType
1326 Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp, Listener *hijack_listener)
1327 {
1328     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1329 
1330     if (log)
1331         log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1332                      static_cast<const void*>(timeout));
1333 
1334     Listener *listener = hijack_listener;
1335     if (listener == NULL)
1336         listener = &m_listener;
1337 
1338     StateType state = eStateInvalid;
1339     if (listener->WaitForEventForBroadcasterWithType (timeout,
1340                                                       this,
1341                                                       eBroadcastBitStateChanged | eBroadcastBitInterrupt,
1342                                                       event_sp))
1343     {
1344         if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1345             state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1346         else if (log)
1347             log->Printf ("Process::%s got no event or was interrupted.", __FUNCTION__);
1348     }
1349 
1350     if (log)
1351         log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
1352                      __FUNCTION__, static_cast<const void*>(timeout),
1353                      StateAsCString(state));
1354     return state;
1355 }
1356 
1357 Event *
1358 Process::PeekAtStateChangedEvents ()
1359 {
1360     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1361 
1362     if (log)
1363         log->Printf ("Process::%s...", __FUNCTION__);
1364 
1365     Event *event_ptr;
1366     event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this,
1367                                                                   eBroadcastBitStateChanged);
1368     if (log)
1369     {
1370         if (event_ptr)
1371         {
1372             log->Printf ("Process::%s (event_ptr) => %s",
1373                          __FUNCTION__,
1374                          StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr)));
1375         }
1376         else
1377         {
1378             log->Printf ("Process::%s no events found",
1379                          __FUNCTION__);
1380         }
1381     }
1382     return event_ptr;
1383 }
1384 
1385 StateType
1386 Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp)
1387 {
1388     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1389 
1390     if (log)
1391         log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1392                      static_cast<const void*>(timeout));
1393 
1394     StateType state = eStateInvalid;
1395     if (m_private_state_listener.WaitForEventForBroadcasterWithType (timeout,
1396                                                                      &m_private_state_broadcaster,
1397                                                                      eBroadcastBitStateChanged | eBroadcastBitInterrupt,
1398                                                                      event_sp))
1399         if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1400             state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1401 
1402     // This is a bit of a hack, but when we wait here we could very well return
1403     // to the command-line, and that could disable the log, which would render the
1404     // log we got above invalid.
1405     if (log)
1406         log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
1407                      __FUNCTION__, static_cast<const void *>(timeout),
1408                      state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
1409     return state;
1410 }
1411 
1412 bool
1413 Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only)
1414 {
1415     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1416 
1417     if (log)
1418         log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1419                      static_cast<const void*>(timeout));
1420 
1421     if (control_only)
1422         return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp);
1423     else
1424         return m_private_state_listener.WaitForEvent(timeout, event_sp);
1425 }
1426 
1427 bool
1428 Process::IsRunning () const
1429 {
1430     return StateIsRunningState (m_public_state.GetValue());
1431 }
1432 
1433 int
1434 Process::GetExitStatus ()
1435 {
1436     Mutex::Locker locker (m_exit_status_mutex);
1437 
1438     if (m_public_state.GetValue() == eStateExited)
1439         return m_exit_status;
1440     return -1;
1441 }
1442 
1443 
1444 const char *
1445 Process::GetExitDescription ()
1446 {
1447     Mutex::Locker locker (m_exit_status_mutex);
1448 
1449     if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
1450         return m_exit_string.c_str();
1451     return NULL;
1452 }
1453 
1454 bool
1455 Process::SetExitStatus (int status, const char *cstr)
1456 {
1457     // Use a mutex to protect setting the exit status.
1458     Mutex::Locker locker (m_exit_status_mutex);
1459 
1460     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
1461     if (log)
1462         log->Printf("Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1463                     status, status,
1464                     cstr ? "\"" : "",
1465                     cstr ? cstr : "NULL",
1466                     cstr ? "\"" : "");
1467 
1468     // We were already in the exited state
1469     if (m_private_state.GetValue() == eStateExited)
1470     {
1471         if (log)
1472             log->Printf("Process::SetExitStatus () ignoring exit status because state was already set to eStateExited");
1473         return false;
1474     }
1475 
1476     m_exit_status = status;
1477     if (cstr)
1478         m_exit_string = cstr;
1479     else
1480         m_exit_string.clear();
1481 
1482     // When we exit, we no longer need to the communication channel
1483     m_stdio_communication.Disconnect();
1484     m_stdio_communication.StopReadThread();
1485     m_stdin_forward = false;
1486 
1487     // And we don't need the input reader anymore as well
1488     if (m_process_input_reader)
1489     {
1490         m_process_input_reader->SetIsDone(true);
1491         m_process_input_reader->Cancel();
1492         m_process_input_reader.reset();
1493     }
1494 
1495     // Clear the last natural stop ID since it has a strong
1496     // reference to this process
1497     m_mod_id.SetStopEventForLastNaturalStopID(EventSP());
1498 
1499     SetPrivateState (eStateExited);
1500 
1501     // Allow subclasses to do some cleanup
1502     DidExit ();
1503 
1504     return true;
1505 }
1506 
1507 // This static callback can be used to watch for local child processes on
1508 // the current host. The child process exits, the process will be
1509 // found in the global target list (we want to be completely sure that the
1510 // lldb_private::Process doesn't go away before we can deliver the signal.
1511 bool
1512 Process::SetProcessExitStatus (void *callback_baton,
1513                                lldb::pid_t pid,
1514                                bool exited,
1515                                int signo,          // Zero for no signal
1516                                int exit_status     // Exit value of process if signal is zero
1517 )
1518 {
1519     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
1520     if (log)
1521         log->Printf ("Process::SetProcessExitStatus (baton=%p, pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n",
1522                      callback_baton,
1523                      pid,
1524                      exited,
1525                      signo,
1526                      exit_status);
1527 
1528     if (exited)
1529     {
1530         TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
1531         if (target_sp)
1532         {
1533             ProcessSP process_sp (target_sp->GetProcessSP());
1534             if (process_sp)
1535             {
1536                 const char *signal_cstr = NULL;
1537                 if (signo)
1538                     signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
1539 
1540                 process_sp->SetExitStatus (exit_status, signal_cstr);
1541             }
1542         }
1543         return true;
1544     }
1545     return false;
1546 }
1547 
1548 
1549 void
1550 Process::UpdateThreadListIfNeeded ()
1551 {
1552     const uint32_t stop_id = GetStopID();
1553     if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID())
1554     {
1555         const StateType state = GetPrivateState();
1556         if (StateIsStoppedState (state, true))
1557         {
1558             Mutex::Locker locker (m_thread_list.GetMutex ());
1559             // m_thread_list does have its own mutex, but we need to
1560             // hold onto the mutex between the call to UpdateThreadList(...)
1561             // and the os->UpdateThreadList(...) so it doesn't change on us
1562             ThreadList &old_thread_list = m_thread_list;
1563             ThreadList real_thread_list(this);
1564             ThreadList new_thread_list(this);
1565             // Always update the thread list with the protocol specific
1566             // thread list, but only update if "true" is returned
1567             if (UpdateThreadList (m_thread_list_real, real_thread_list))
1568             {
1569                 // Don't call into the OperatingSystem to update the thread list if we are shutting down, since
1570                 // that may call back into the SBAPI's, requiring the API lock which is already held by whoever is
1571                 // shutting us down, causing a deadlock.
1572                 if (!m_destroy_in_process)
1573                 {
1574                     OperatingSystem *os = GetOperatingSystem ();
1575                     if (os)
1576                     {
1577                         // Clear any old backing threads where memory threads might have been
1578                         // backed by actual threads from the lldb_private::Process subclass
1579                         size_t num_old_threads = old_thread_list.GetSize(false);
1580                         for (size_t i=0; i<num_old_threads; ++i)
1581                             old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
1582 
1583                         // Turn off dynamic types to ensure we don't run any expressions. Objective C
1584                         // can run an expression to determine if a SBValue is a dynamic type or not
1585                         // and we need to avoid this. OperatingSystem plug-ins can't run expressions
1586                         // that require running code...
1587 
1588                         Target &target = GetTarget();
1589                         const lldb::DynamicValueType saved_prefer_dynamic = target.GetPreferDynamicValue ();
1590                         if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1591                             target.SetPreferDynamicValue(lldb::eNoDynamicValues);
1592 
1593                         // Now let the OperatingSystem plug-in update the thread list
1594 
1595                         os->UpdateThreadList (old_thread_list,  // Old list full of threads created by OS plug-in
1596                                               real_thread_list, // The actual thread list full of threads created by each lldb_private::Process subclass
1597                                               new_thread_list); // The new thread list that we will show to the user that gets filled in
1598 
1599                         if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1600                             target.SetPreferDynamicValue(saved_prefer_dynamic);
1601                     }
1602                     else
1603                     {
1604                         // No OS plug-in, the new thread list is the same as the real thread list
1605                         new_thread_list = real_thread_list;
1606                     }
1607                 }
1608 
1609                 m_thread_list_real.Update(real_thread_list);
1610                 m_thread_list.Update (new_thread_list);
1611                 m_thread_list.SetStopID (stop_id);
1612 
1613                 if (GetLastNaturalStopID () != m_extended_thread_stop_id)
1614                 {
1615                     // Clear any extended threads that we may have accumulated previously
1616                     m_extended_thread_list.Clear();
1617                     m_extended_thread_stop_id = GetLastNaturalStopID ();
1618 
1619                     m_queue_list.Clear();
1620                     m_queue_list_stop_id = GetLastNaturalStopID ();
1621                 }
1622             }
1623         }
1624     }
1625 }
1626 
1627 void
1628 Process::UpdateQueueListIfNeeded ()
1629 {
1630     if (m_system_runtime_ap.get())
1631     {
1632         if (m_queue_list.GetSize() == 0 || m_queue_list_stop_id != GetLastNaturalStopID())
1633         {
1634             const StateType state = GetPrivateState();
1635             if (StateIsStoppedState (state, true))
1636             {
1637                 m_system_runtime_ap->PopulateQueueList (m_queue_list);
1638                 m_queue_list_stop_id = GetLastNaturalStopID();
1639             }
1640         }
1641     }
1642 }
1643 
1644 ThreadSP
1645 Process::CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context)
1646 {
1647     OperatingSystem *os = GetOperatingSystem ();
1648     if (os)
1649         return os->CreateThread(tid, context);
1650     return ThreadSP();
1651 }
1652 
1653 uint32_t
1654 Process::GetNextThreadIndexID (uint64_t thread_id)
1655 {
1656     return AssignIndexIDToThread(thread_id);
1657 }
1658 
1659 bool
1660 Process::HasAssignedIndexIDToThread(uint64_t thread_id)
1661 {
1662     std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
1663     if (iterator == m_thread_id_to_index_id_map.end())
1664     {
1665         return false;
1666     }
1667     else
1668     {
1669         return true;
1670     }
1671 }
1672 
1673 uint32_t
1674 Process::AssignIndexIDToThread(uint64_t thread_id)
1675 {
1676     uint32_t result = 0;
1677     std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
1678     if (iterator == m_thread_id_to_index_id_map.end())
1679     {
1680         result = ++m_thread_index_id;
1681         m_thread_id_to_index_id_map[thread_id] = result;
1682     }
1683     else
1684     {
1685         result = iterator->second;
1686     }
1687 
1688     return result;
1689 }
1690 
1691 StateType
1692 Process::GetState()
1693 {
1694     // If any other threads access this we will need a mutex for it
1695     return m_public_state.GetValue ();
1696 }
1697 
1698 bool
1699 Process::StateChangedIsExternallyHijacked()
1700 {
1701     if (IsHijackedForEvent(eBroadcastBitStateChanged))
1702     {
1703         if (strcmp(m_hijacking_listeners.back()->GetName(), "lldb.Process.ResumeSynchronous.hijack"))
1704             return true;
1705     }
1706     return false;
1707 }
1708 
1709 void
1710 Process::SetPublicState (StateType new_state, bool restarted)
1711 {
1712     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
1713     if (log)
1714         log->Printf("Process::SetPublicState (state = %s, restarted = %i)", StateAsCString(new_state), restarted);
1715     const StateType old_state = m_public_state.GetValue();
1716     m_public_state.SetValue (new_state);
1717 
1718     // On the transition from Run to Stopped, we unlock the writer end of the
1719     // run lock.  The lock gets locked in Resume, which is the public API
1720     // to tell the program to run.
1721     if (!StateChangedIsExternallyHijacked())
1722     {
1723         if (new_state == eStateDetached)
1724         {
1725             if (log)
1726                 log->Printf("Process::SetPublicState (%s) -- unlocking run lock for detach", StateAsCString(new_state));
1727             m_public_run_lock.SetStopped();
1728         }
1729         else
1730         {
1731             const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1732             const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1733             if ((old_state_is_stopped != new_state_is_stopped))
1734             {
1735                 if (new_state_is_stopped && !restarted)
1736                 {
1737                     if (log)
1738                         log->Printf("Process::SetPublicState (%s) -- unlocking run lock", StateAsCString(new_state));
1739                     m_public_run_lock.SetStopped();
1740                 }
1741             }
1742         }
1743     }
1744 }
1745 
1746 Error
1747 Process::Resume ()
1748 {
1749     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
1750     if (log)
1751         log->Printf("Process::Resume -- locking run lock");
1752     if (!m_public_run_lock.TrySetRunning())
1753     {
1754         Error error("Resume request failed - process still running.");
1755         if (log)
1756             log->Printf ("Process::Resume: -- TrySetRunning failed, not resuming.");
1757         return error;
1758     }
1759     return PrivateResume();
1760 }
1761 
1762 Error
1763 Process::ResumeSynchronous (Stream *stream)
1764 {
1765     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
1766     if (log)
1767         log->Printf("Process::ResumeSynchronous -- locking run lock");
1768     if (!m_public_run_lock.TrySetRunning())
1769     {
1770         Error error("Resume request failed - process still running.");
1771         if (log)
1772             log->Printf ("Process::Resume: -- TrySetRunning failed, not resuming.");
1773         return error;
1774     }
1775 
1776     ListenerSP listener_sp (new Listener("lldb.Process.ResumeSynchronous.hijack"));
1777     HijackProcessEvents(listener_sp.get());
1778 
1779     Error error = PrivateResume();
1780     if (error.Success())
1781     {
1782         StateType state = WaitForProcessToStop (NULL, NULL, true, listener_sp.get(), stream);
1783         const bool must_be_alive = false; // eStateExited is ok, so this must be false
1784         if (!StateIsStoppedState(state, must_be_alive))
1785             error.SetErrorStringWithFormat("process not in stopped state after synchronous resume: %s", StateAsCString(state));
1786     }
1787 
1788     // Undo the hijacking of process events...
1789     RestoreProcessEvents();
1790 
1791     return error;
1792 }
1793 
1794 StateType
1795 Process::GetPrivateState ()
1796 {
1797     return m_private_state.GetValue();
1798 }
1799 
1800 void
1801 Process::SetPrivateState (StateType new_state)
1802 {
1803     if (m_finalize_called)
1804         return;
1805 
1806     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
1807     bool state_changed = false;
1808 
1809     if (log)
1810         log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
1811 
1812     Mutex::Locker thread_locker(m_thread_list.GetMutex());
1813     Mutex::Locker locker(m_private_state.GetMutex());
1814 
1815     const StateType old_state = m_private_state.GetValueNoLock ();
1816     state_changed = old_state != new_state;
1817 
1818     const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1819     const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1820     if (old_state_is_stopped != new_state_is_stopped)
1821     {
1822         if (new_state_is_stopped)
1823             m_private_run_lock.SetStopped();
1824         else
1825             m_private_run_lock.SetRunning();
1826     }
1827 
1828     if (state_changed)
1829     {
1830         m_private_state.SetValueNoLock (new_state);
1831         EventSP event_sp (new Event (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state)));
1832         if (StateIsStoppedState(new_state, false))
1833         {
1834             // Note, this currently assumes that all threads in the list
1835             // stop when the process stops.  In the future we will want to
1836             // support a debugging model where some threads continue to run
1837             // while others are stopped.  When that happens we will either need
1838             // a way for the thread list to identify which threads are stopping
1839             // or create a special thread list containing only threads which
1840             // actually stopped.
1841             //
1842             // The process plugin is responsible for managing the actual
1843             // behavior of the threads and should have stopped any threads
1844             // that are going to stop before we get here.
1845             m_thread_list.DidStop();
1846 
1847             m_mod_id.BumpStopID();
1848             if (!m_mod_id.IsLastResumeForUserExpression())
1849                 m_mod_id.SetStopEventForLastNaturalStopID(event_sp);
1850             m_memory_cache.Clear();
1851             if (log)
1852                 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_mod_id.GetStopID());
1853         }
1854 
1855         // Use our target to get a shared pointer to ourselves...
1856         if (m_finalize_called && PrivateStateThreadIsValid() == false)
1857             BroadcastEvent (event_sp);
1858         else
1859             m_private_state_broadcaster.BroadcastEvent (event_sp);
1860     }
1861     else
1862     {
1863         if (log)
1864             log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state));
1865     }
1866 }
1867 
1868 void
1869 Process::SetRunningUserExpression (bool on)
1870 {
1871     m_mod_id.SetRunningUserExpression (on);
1872 }
1873 
1874 addr_t
1875 Process::GetImageInfoAddress()
1876 {
1877     return LLDB_INVALID_ADDRESS;
1878 }
1879 
1880 //----------------------------------------------------------------------
1881 // LoadImage
1882 //
1883 // This function provides a default implementation that works for most
1884 // unix variants. Any Process subclasses that need to do shared library
1885 // loading differently should override LoadImage and UnloadImage and
1886 // do what is needed.
1887 //----------------------------------------------------------------------
1888 uint32_t
1889 Process::LoadImage (const FileSpec &image_spec, Error &error)
1890 {
1891     if (m_finalizing)
1892     {
1893         error.SetErrorString("process is tearing itself down");
1894         return LLDB_INVALID_IMAGE_TOKEN;
1895     }
1896 
1897     char path[PATH_MAX];
1898     image_spec.GetPath(path, sizeof(path));
1899 
1900     DynamicLoader *loader = GetDynamicLoader();
1901     if (loader)
1902     {
1903         error = loader->CanLoadImage();
1904         if (error.Fail())
1905             return LLDB_INVALID_IMAGE_TOKEN;
1906     }
1907 
1908     if (error.Success())
1909     {
1910         ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
1911 
1912         if (thread_sp)
1913         {
1914             StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
1915 
1916             if (frame_sp)
1917             {
1918                 ExecutionContext exe_ctx;
1919                 frame_sp->CalculateExecutionContext (exe_ctx);
1920                 EvaluateExpressionOptions expr_options;
1921                 expr_options.SetUnwindOnError(true);
1922                 expr_options.SetIgnoreBreakpoints(true);
1923                 expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
1924                 expr_options.SetResultIsInternal(true);
1925 
1926                 StreamString expr;
1927                 expr.Printf(R"(
1928                                struct __lldb_dlopen_result { void *image_ptr; const char *error_str; } the_result;
1929                                the_result.image_ptr = dlopen ("%s", 2);
1930                                if (the_result.image_ptr == (void *) 0x0)
1931                                {
1932                                    the_result.error_str = dlerror();
1933                                }
1934                                else
1935                                {
1936                                    the_result.error_str = (const char *) 0x0;
1937                                }
1938                                the_result;
1939                               )",
1940                               path);
1941                 const char *prefix = R"(
1942                                         extern "C" void* dlopen (const char *path, int mode);
1943                                         extern "C" const char *dlerror (void);
1944                                         )";
1945                 lldb::ValueObjectSP result_valobj_sp;
1946                 Error expr_error;
1947                 ClangUserExpression::Evaluate (exe_ctx,
1948                                                expr_options,
1949                                                expr.GetData(),
1950                                                prefix,
1951                                                result_valobj_sp,
1952                                                expr_error);
1953                 if (expr_error.Success())
1954                 {
1955                     error = result_valobj_sp->GetError();
1956                     if (error.Success())
1957                     {
1958                         Scalar scalar;
1959                         ValueObjectSP image_ptr_sp = result_valobj_sp->GetChildAtIndex(0, true);
1960                         if (image_ptr_sp && image_ptr_sp->ResolveValue (scalar))
1961                         {
1962                             addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1963                             if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
1964                             {
1965                                 uint32_t image_token = m_image_tokens.size();
1966                                 m_image_tokens.push_back (image_ptr);
1967                                 return image_token;
1968                             }
1969                             else if (image_ptr == 0)
1970                             {
1971                                 ValueObjectSP error_str_sp = result_valobj_sp->GetChildAtIndex(1, true);
1972                                 if (error_str_sp)
1973                                 {
1974                                     if (error_str_sp->IsCStringContainer(true))
1975                                     {
1976                                         DataBufferSP buffer_sp(new DataBufferHeap(10240,0));
1977                                         size_t num_chars = error_str_sp->ReadPointedString (buffer_sp, error, 10240);
1978                                         if (error.Success() && num_chars > 0)
1979                                         {
1980                                             error.Clear();
1981                                             error.SetErrorStringWithFormat("dlopen error: %s", buffer_sp->GetBytes());
1982                                         }
1983                                         else
1984                                         {
1985                                             error.Clear();
1986                                             error.SetErrorStringWithFormat("dlopen failed for unknown reasons.");
1987                                         }
1988                                     }
1989                                 }
1990                             }
1991                         }
1992                     }
1993                 }
1994                 else
1995                     error = expr_error;
1996             }
1997         }
1998     }
1999     if (!error.AsCString())
2000         error.SetErrorStringWithFormat("unable to load '%s'", path);
2001     return LLDB_INVALID_IMAGE_TOKEN;
2002 }
2003 
2004 //----------------------------------------------------------------------
2005 // UnloadImage
2006 //
2007 // This function provides a default implementation that works for most
2008 // unix variants. Any Process subclasses that need to do shared library
2009 // loading differently should override LoadImage and UnloadImage and
2010 // do what is needed.
2011 //----------------------------------------------------------------------
2012 Error
2013 Process::UnloadImage (uint32_t image_token)
2014 {
2015     Error error;
2016 
2017     if (m_finalizing)
2018     {
2019         error.SetErrorString("process is tearing itself down");
2020         return error;
2021     }
2022 
2023     if (image_token < m_image_tokens.size())
2024     {
2025         const addr_t image_addr = m_image_tokens[image_token];
2026         if (image_addr == LLDB_INVALID_ADDRESS)
2027         {
2028             error.SetErrorString("image already unloaded");
2029         }
2030         else
2031         {
2032             DynamicLoader *loader = GetDynamicLoader();
2033             if (loader)
2034                 error = loader->CanLoadImage();
2035 
2036             if (error.Success())
2037             {
2038                 ThreadSP thread_sp(GetThreadList ().GetSelectedThread());
2039 
2040                 if (thread_sp)
2041                 {
2042                     StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex (0));
2043 
2044                     if (frame_sp)
2045                     {
2046                         ExecutionContext exe_ctx;
2047                         frame_sp->CalculateExecutionContext (exe_ctx);
2048                         EvaluateExpressionOptions expr_options;
2049                         expr_options.SetUnwindOnError(true);
2050                         expr_options.SetIgnoreBreakpoints(true);
2051                         expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
2052                         StreamString expr;
2053                         expr.Printf("dlclose ((void *)0x%" PRIx64 ")", image_addr);
2054                         const char *prefix = "extern \"C\" int dlclose(void* handle);\n";
2055                         lldb::ValueObjectSP result_valobj_sp;
2056                         Error expr_error;
2057                         ClangUserExpression::Evaluate (exe_ctx,
2058                                                        expr_options,
2059                                                        expr.GetData(),
2060                                                        prefix,
2061                                                        result_valobj_sp,
2062                                                        expr_error);
2063                         if (result_valobj_sp->GetError().Success())
2064                         {
2065                             Scalar scalar;
2066                             if (result_valobj_sp->ResolveValue (scalar))
2067                             {
2068                                 if (scalar.UInt(1))
2069                                 {
2070                                     error.SetErrorStringWithFormat("expression failed: \"%s\"", expr.GetData());
2071                                 }
2072                                 else
2073                                 {
2074                                     m_image_tokens[image_token] = LLDB_INVALID_ADDRESS;
2075                                 }
2076                             }
2077                         }
2078                         else
2079                         {
2080                             error = result_valobj_sp->GetError();
2081                         }
2082                     }
2083                 }
2084             }
2085         }
2086     }
2087     else
2088     {
2089         error.SetErrorString("invalid image token");
2090     }
2091     return error;
2092 }
2093 
2094 const lldb::ABISP &
2095 Process::GetABI()
2096 {
2097     if (!m_abi_sp)
2098         m_abi_sp = ABI::FindPlugin(m_target.GetArchitecture());
2099     return m_abi_sp;
2100 }
2101 
2102 LanguageRuntime *
2103 Process::GetLanguageRuntime(lldb::LanguageType language, bool retry_if_null)
2104 {
2105     if (m_finalizing)
2106         return nullptr;
2107 
2108     LanguageRuntimeCollection::iterator pos;
2109     pos = m_language_runtimes.find (language);
2110     if (pos == m_language_runtimes.end() || (retry_if_null && !(*pos).second))
2111     {
2112         lldb::LanguageRuntimeSP runtime_sp(LanguageRuntime::FindPlugin(this, language));
2113 
2114         m_language_runtimes[language] = runtime_sp;
2115         return runtime_sp.get();
2116     }
2117     else
2118         return (*pos).second.get();
2119 }
2120 
2121 CPPLanguageRuntime *
2122 Process::GetCPPLanguageRuntime (bool retry_if_null)
2123 {
2124     LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus, retry_if_null);
2125     if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
2126         return static_cast<CPPLanguageRuntime *> (runtime);
2127     return NULL;
2128 }
2129 
2130 ObjCLanguageRuntime *
2131 Process::GetObjCLanguageRuntime (bool retry_if_null)
2132 {
2133     LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC, retry_if_null);
2134     if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC)
2135         return static_cast<ObjCLanguageRuntime *> (runtime);
2136     return NULL;
2137 }
2138 
2139 bool
2140 Process::IsPossibleDynamicValue (ValueObject& in_value)
2141 {
2142     if (m_finalizing)
2143         return false;
2144 
2145     if (in_value.IsDynamic())
2146         return false;
2147     LanguageType known_type = in_value.GetObjectRuntimeLanguage();
2148 
2149     if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC)
2150     {
2151         LanguageRuntime *runtime = GetLanguageRuntime (known_type);
2152         return runtime ? runtime->CouldHaveDynamicValue(in_value) : false;
2153     }
2154 
2155     LanguageRuntime *cpp_runtime = GetLanguageRuntime (eLanguageTypeC_plus_plus);
2156     if (cpp_runtime && cpp_runtime->CouldHaveDynamicValue(in_value))
2157         return true;
2158 
2159     LanguageRuntime *objc_runtime = GetLanguageRuntime (eLanguageTypeObjC);
2160     return objc_runtime ? objc_runtime->CouldHaveDynamicValue(in_value) : false;
2161 }
2162 
2163 void
2164 Process::SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers)
2165 {
2166     m_dynamic_checkers_ap.reset(dynamic_checkers);
2167 }
2168 
2169 BreakpointSiteList &
2170 Process::GetBreakpointSiteList()
2171 {
2172     return m_breakpoint_site_list;
2173 }
2174 
2175 const BreakpointSiteList &
2176 Process::GetBreakpointSiteList() const
2177 {
2178     return m_breakpoint_site_list;
2179 }
2180 
2181 
2182 void
2183 Process::DisableAllBreakpointSites ()
2184 {
2185     m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void {
2186 //        bp_site->SetEnabled(true);
2187         DisableBreakpointSite(bp_site);
2188     });
2189 }
2190 
2191 Error
2192 Process::ClearBreakpointSiteByID (lldb::user_id_t break_id)
2193 {
2194     Error error (DisableBreakpointSiteByID (break_id));
2195 
2196     if (error.Success())
2197         m_breakpoint_site_list.Remove(break_id);
2198 
2199     return error;
2200 }
2201 
2202 Error
2203 Process::DisableBreakpointSiteByID (lldb::user_id_t break_id)
2204 {
2205     Error error;
2206     BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
2207     if (bp_site_sp)
2208     {
2209         if (bp_site_sp->IsEnabled())
2210             error = DisableBreakpointSite (bp_site_sp.get());
2211     }
2212     else
2213     {
2214         error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
2215     }
2216 
2217     return error;
2218 }
2219 
2220 Error
2221 Process::EnableBreakpointSiteByID (lldb::user_id_t break_id)
2222 {
2223     Error error;
2224     BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
2225     if (bp_site_sp)
2226     {
2227         if (!bp_site_sp->IsEnabled())
2228             error = EnableBreakpointSite (bp_site_sp.get());
2229     }
2230     else
2231     {
2232         error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
2233     }
2234     return error;
2235 }
2236 
2237 lldb::break_id_t
2238 Process::CreateBreakpointSite (const BreakpointLocationSP &owner, bool use_hardware)
2239 {
2240     addr_t load_addr = LLDB_INVALID_ADDRESS;
2241 
2242     bool show_error = true;
2243     switch (GetState())
2244     {
2245         case eStateInvalid:
2246         case eStateUnloaded:
2247         case eStateConnected:
2248         case eStateAttaching:
2249         case eStateLaunching:
2250         case eStateDetached:
2251         case eStateExited:
2252             show_error = false;
2253             break;
2254 
2255         case eStateStopped:
2256         case eStateRunning:
2257         case eStateStepping:
2258         case eStateCrashed:
2259         case eStateSuspended:
2260             show_error = IsAlive();
2261             break;
2262     }
2263 
2264     // Reset the IsIndirect flag here, in case the location changes from
2265     // pointing to a indirect symbol to a regular symbol.
2266     owner->SetIsIndirect (false);
2267 
2268     if (owner->ShouldResolveIndirectFunctions())
2269     {
2270         Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
2271         if (symbol && symbol->IsIndirect())
2272         {
2273             Error error;
2274             Address symbol_address = symbol->GetAddress();
2275             load_addr = ResolveIndirectFunction (&symbol_address, error);
2276             if (!error.Success() && show_error)
2277             {
2278                 m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to resolve indirect function at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
2279                                                                symbol->GetLoadAddress(&m_target),
2280                                                                owner->GetBreakpoint().GetID(),
2281                                                                owner->GetID(),
2282                                                                error.AsCString() ? error.AsCString() : "unknown error");
2283                 return LLDB_INVALID_BREAK_ID;
2284             }
2285             Address resolved_address(load_addr);
2286             load_addr = resolved_address.GetOpcodeLoadAddress (&m_target);
2287             owner->SetIsIndirect(true);
2288         }
2289         else
2290             load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
2291     }
2292     else
2293         load_addr = owner->GetAddress().GetOpcodeLoadAddress (&m_target);
2294 
2295     if (load_addr != LLDB_INVALID_ADDRESS)
2296     {
2297         BreakpointSiteSP bp_site_sp;
2298 
2299         // Look up this breakpoint site.  If it exists, then add this new owner, otherwise
2300         // create a new breakpoint site and add it.
2301 
2302         bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr);
2303 
2304         if (bp_site_sp)
2305         {
2306             bp_site_sp->AddOwner (owner);
2307             owner->SetBreakpointSite (bp_site_sp);
2308             return bp_site_sp->GetID();
2309         }
2310         else
2311         {
2312             bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, use_hardware));
2313             if (bp_site_sp)
2314             {
2315                 Error error = EnableBreakpointSite (bp_site_sp.get());
2316                 if (error.Success())
2317                 {
2318                     owner->SetBreakpointSite (bp_site_sp);
2319                     return m_breakpoint_site_list.Add (bp_site_sp);
2320                 }
2321                 else
2322                 {
2323                     if (show_error)
2324                     {
2325                         // Report error for setting breakpoint...
2326                         m_target.GetDebugger().GetErrorFile()->Printf ("warning: failed to set breakpoint site at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
2327                                                                        load_addr,
2328                                                                        owner->GetBreakpoint().GetID(),
2329                                                                        owner->GetID(),
2330                                                                        error.AsCString() ? error.AsCString() : "unknown error");
2331                     }
2332                 }
2333             }
2334         }
2335     }
2336     // We failed to enable the breakpoint
2337     return LLDB_INVALID_BREAK_ID;
2338 
2339 }
2340 
2341 void
2342 Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp)
2343 {
2344     uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id);
2345     if (num_owners == 0)
2346     {
2347         // Don't try to disable the site if we don't have a live process anymore.
2348         if (IsAlive())
2349             DisableBreakpointSite (bp_site_sp.get());
2350         m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
2351     }
2352 }
2353 
2354 
2355 size_t
2356 Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
2357 {
2358     size_t bytes_removed = 0;
2359     BreakpointSiteList bp_sites_in_range;
2360 
2361     if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range))
2362     {
2363         bp_sites_in_range.ForEach([bp_addr, size, buf, &bytes_removed](BreakpointSite *bp_site) -> void {
2364             if (bp_site->GetType() == BreakpointSite::eSoftware)
2365             {
2366                 addr_t intersect_addr;
2367                 size_t intersect_size;
2368                 size_t opcode_offset;
2369                 if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset))
2370                 {
2371                     assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
2372                     assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size);
2373                     assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
2374                     size_t buf_offset = intersect_addr - bp_addr;
2375                     ::memcpy(buf + buf_offset, bp_site->GetSavedOpcodeBytes() + opcode_offset, intersect_size);
2376                 }
2377             }
2378         });
2379     }
2380     return bytes_removed;
2381 }
2382 
2383 
2384 
2385 size_t
2386 Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
2387 {
2388     PlatformSP platform_sp (m_target.GetPlatform());
2389     if (platform_sp)
2390         return platform_sp->GetSoftwareBreakpointTrapOpcode (m_target, bp_site);
2391     return 0;
2392 }
2393 
2394 Error
2395 Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site)
2396 {
2397     Error error;
2398     assert (bp_site != NULL);
2399     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
2400     const addr_t bp_addr = bp_site->GetLoadAddress();
2401     if (log)
2402         log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64, bp_site->GetID(), (uint64_t)bp_addr);
2403     if (bp_site->IsEnabled())
2404     {
2405         if (log)
2406             log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- already enabled", bp_site->GetID(), (uint64_t)bp_addr);
2407         return error;
2408     }
2409 
2410     if (bp_addr == LLDB_INVALID_ADDRESS)
2411     {
2412         error.SetErrorString("BreakpointSite contains an invalid load address.");
2413         return error;
2414     }
2415     // Ask the lldb::Process subclass to fill in the correct software breakpoint
2416     // trap for the breakpoint site
2417     const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
2418 
2419     if (bp_opcode_size == 0)
2420     {
2421         error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%" PRIx64, bp_addr);
2422     }
2423     else
2424     {
2425         const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
2426 
2427         if (bp_opcode_bytes == NULL)
2428         {
2429             error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode.");
2430             return error;
2431         }
2432 
2433         // Save the original opcode by reading it
2434         if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size)
2435         {
2436             // Write a software breakpoint in place of the original opcode
2437             if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2438             {
2439                 uint8_t verify_bp_opcode_bytes[64];
2440                 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2441                 {
2442                     if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0)
2443                     {
2444                         bp_site->SetEnabled(true);
2445                         bp_site->SetType (BreakpointSite::eSoftware);
2446                         if (log)
2447                             log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS",
2448                                          bp_site->GetID(),
2449                                          (uint64_t)bp_addr);
2450                     }
2451                     else
2452                         error.SetErrorString("failed to verify the breakpoint trap in memory.");
2453                 }
2454                 else
2455                     error.SetErrorString("Unable to read memory to verify breakpoint trap.");
2456             }
2457             else
2458                 error.SetErrorString("Unable to write breakpoint trap to memory.");
2459         }
2460         else
2461             error.SetErrorString("Unable to read memory at breakpoint address.");
2462     }
2463     if (log && error.Fail())
2464         log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
2465                      bp_site->GetID(),
2466                      (uint64_t)bp_addr,
2467                      error.AsCString());
2468     return error;
2469 }
2470 
2471 Error
2472 Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
2473 {
2474     Error error;
2475     assert (bp_site != NULL);
2476     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
2477     addr_t bp_addr = bp_site->GetLoadAddress();
2478     lldb::user_id_t breakID = bp_site->GetID();
2479     if (log)
2480         log->Printf ("Process::DisableSoftwareBreakpoint (breakID = %" PRIu64 ") addr = 0x%" PRIx64, breakID, (uint64_t)bp_addr);
2481 
2482     if (bp_site->IsHardware())
2483     {
2484         error.SetErrorString("Breakpoint site is a hardware breakpoint.");
2485     }
2486     else if (bp_site->IsEnabled())
2487     {
2488         const size_t break_op_size = bp_site->GetByteSize();
2489         const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
2490         if (break_op_size > 0)
2491         {
2492             // Clear a software breakpoint instruction
2493             uint8_t curr_break_op[8];
2494             assert (break_op_size <= sizeof(curr_break_op));
2495             bool break_op_found = false;
2496 
2497             // Read the breakpoint opcode
2498             if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
2499             {
2500                 bool verify = false;
2501                 // Make sure the breakpoint opcode exists at this address
2502                 if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
2503                 {
2504                     break_op_found = true;
2505                     // We found a valid breakpoint opcode at this address, now restore
2506                     // the saved opcode.
2507                     if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size)
2508                     {
2509                         verify = true;
2510                     }
2511                     else
2512                         error.SetErrorString("Memory write failed when restoring original opcode.");
2513                 }
2514                 else
2515                 {
2516                     error.SetErrorString("Original breakpoint trap is no longer in memory.");
2517                     // Set verify to true and so we can check if the original opcode has already been restored
2518                     verify = true;
2519                 }
2520 
2521                 if (verify)
2522                 {
2523                     uint8_t verify_opcode[8];
2524                     assert (break_op_size < sizeof(verify_opcode));
2525                     // Verify that our original opcode made it back to the inferior
2526                     if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size)
2527                     {
2528                         // compare the memory we just read with the original opcode
2529                         if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
2530                         {
2531                             // SUCCESS
2532                             bp_site->SetEnabled(false);
2533                             if (log)
2534                                 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS", bp_site->GetID(), (uint64_t)bp_addr);
2535                             return error;
2536                         }
2537                         else
2538                         {
2539                             if (break_op_found)
2540                                 error.SetErrorString("Failed to restore original opcode.");
2541                         }
2542                     }
2543                     else
2544                         error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored.");
2545                 }
2546             }
2547             else
2548                 error.SetErrorString("Unable to read memory that should contain the breakpoint trap.");
2549         }
2550     }
2551     else
2552     {
2553         if (log)
2554             log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- already disabled", bp_site->GetID(), (uint64_t)bp_addr);
2555         return error;
2556     }
2557 
2558     if (log)
2559         log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
2560                      bp_site->GetID(),
2561                      (uint64_t)bp_addr,
2562                      error.AsCString());
2563     return error;
2564 
2565 }
2566 
2567 // Uncomment to verify memory caching works after making changes to caching code
2568 //#define VERIFY_MEMORY_READS
2569 
2570 size_t
2571 Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
2572 {
2573     error.Clear();
2574     if (!GetDisableMemoryCache())
2575     {
2576 #if defined (VERIFY_MEMORY_READS)
2577         // Memory caching is enabled, with debug verification
2578 
2579         if (buf && size)
2580         {
2581             // Uncomment the line below to make sure memory caching is working.
2582             // I ran this through the test suite and got no assertions, so I am
2583             // pretty confident this is working well. If any changes are made to
2584             // memory caching, uncomment the line below and test your changes!
2585 
2586             // Verify all memory reads by using the cache first, then redundantly
2587             // reading the same memory from the inferior and comparing to make sure
2588             // everything is exactly the same.
2589             std::string verify_buf (size, '\0');
2590             assert (verify_buf.size() == size);
2591             const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error);
2592             Error verify_error;
2593             const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error);
2594             assert (cache_bytes_read == verify_bytes_read);
2595             assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
2596             assert (verify_error.Success() == error.Success());
2597             return cache_bytes_read;
2598         }
2599         return 0;
2600 #else // !defined(VERIFY_MEMORY_READS)
2601         // Memory caching is enabled, without debug verification
2602 
2603         return m_memory_cache.Read (addr, buf, size, error);
2604 #endif // defined (VERIFY_MEMORY_READS)
2605     }
2606     else
2607     {
2608         // Memory caching is disabled
2609 
2610         return ReadMemoryFromInferior (addr, buf, size, error);
2611     }
2612 }
2613 
2614 size_t
2615 Process::ReadCStringFromMemory (addr_t addr, std::string &out_str, Error &error)
2616 {
2617     char buf[256];
2618     out_str.clear();
2619     addr_t curr_addr = addr;
2620     while (1)
2621     {
2622         size_t length = ReadCStringFromMemory (curr_addr, buf, sizeof(buf), error);
2623         if (length == 0)
2624             break;
2625         out_str.append(buf, length);
2626         // If we got "length - 1" bytes, we didn't get the whole C string, we
2627         // need to read some more characters
2628         if (length == sizeof(buf) - 1)
2629             curr_addr += length;
2630         else
2631             break;
2632     }
2633     return out_str.size();
2634 }
2635 
2636 
2637 size_t
2638 Process::ReadStringFromMemory (addr_t addr, char *dst, size_t max_bytes, Error &error,
2639                                 size_t type_width)
2640 {
2641     size_t total_bytes_read = 0;
2642     if (dst && max_bytes && type_width && max_bytes >= type_width)
2643     {
2644         // Ensure a null terminator independent of the number of bytes that is read.
2645         memset (dst, 0, max_bytes);
2646         size_t bytes_left = max_bytes - type_width;
2647 
2648         const char terminator[4] = {'\0', '\0', '\0', '\0'};
2649         assert(sizeof(terminator) >= type_width &&
2650                "Attempting to validate a string with more than 4 bytes per character!");
2651 
2652         addr_t curr_addr = addr;
2653         const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2654         char *curr_dst = dst;
2655 
2656         error.Clear();
2657         while (bytes_left > 0 && error.Success())
2658         {
2659             addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2660             addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2661             size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2662 
2663             if (bytes_read == 0)
2664                 break;
2665 
2666             // Search for a null terminator of correct size and alignment in bytes_read
2667             size_t aligned_start = total_bytes_read - total_bytes_read % type_width;
2668             for (size_t i = aligned_start; i + type_width <= total_bytes_read + bytes_read; i += type_width)
2669                 if (::strncmp(&dst[i], terminator, type_width) == 0)
2670                 {
2671                     error.Clear();
2672                     return i;
2673                 }
2674 
2675             total_bytes_read += bytes_read;
2676             curr_dst += bytes_read;
2677             curr_addr += bytes_read;
2678             bytes_left -= bytes_read;
2679         }
2680     }
2681     else
2682     {
2683         if (max_bytes)
2684             error.SetErrorString("invalid arguments");
2685     }
2686     return total_bytes_read;
2687 }
2688 
2689 // Deprecated in favor of ReadStringFromMemory which has wchar support and correct code to find
2690 // null terminators.
2691 size_t
2692 Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len, Error &result_error)
2693 {
2694     size_t total_cstr_len = 0;
2695     if (dst && dst_max_len)
2696     {
2697         result_error.Clear();
2698         // NULL out everything just to be safe
2699         memset (dst, 0, dst_max_len);
2700         Error error;
2701         addr_t curr_addr = addr;
2702         const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2703         size_t bytes_left = dst_max_len - 1;
2704         char *curr_dst = dst;
2705 
2706         while (bytes_left > 0)
2707         {
2708             addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2709             addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2710             size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2711 
2712             if (bytes_read == 0)
2713             {
2714                 result_error = error;
2715                 dst[total_cstr_len] = '\0';
2716                 break;
2717             }
2718             const size_t len = strlen(curr_dst);
2719 
2720             total_cstr_len += len;
2721 
2722             if (len < bytes_to_read)
2723                 break;
2724 
2725             curr_dst += bytes_read;
2726             curr_addr += bytes_read;
2727             bytes_left -= bytes_read;
2728         }
2729     }
2730     else
2731     {
2732         if (dst == NULL)
2733             result_error.SetErrorString("invalid arguments");
2734         else
2735             result_error.Clear();
2736     }
2737     return total_cstr_len;
2738 }
2739 
2740 size_t
2741 Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error)
2742 {
2743     if (buf == NULL || size == 0)
2744         return 0;
2745 
2746     size_t bytes_read = 0;
2747     uint8_t *bytes = (uint8_t *)buf;
2748 
2749     while (bytes_read < size)
2750     {
2751         const size_t curr_size = size - bytes_read;
2752         const size_t curr_bytes_read = DoReadMemory (addr + bytes_read,
2753                                                      bytes + bytes_read,
2754                                                      curr_size,
2755                                                      error);
2756         bytes_read += curr_bytes_read;
2757         if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2758             break;
2759     }
2760 
2761     // Replace any software breakpoint opcodes that fall into this range back
2762     // into "buf" before we return
2763     if (bytes_read > 0)
2764         RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf);
2765     return bytes_read;
2766 }
2767 
2768 uint64_t
2769 Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error)
2770 {
2771     Scalar scalar;
2772     if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error))
2773         return scalar.ULongLong(fail_value);
2774     return fail_value;
2775 }
2776 
2777 addr_t
2778 Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
2779 {
2780     Scalar scalar;
2781     if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error))
2782         return scalar.ULongLong(LLDB_INVALID_ADDRESS);
2783     return LLDB_INVALID_ADDRESS;
2784 }
2785 
2786 
2787 bool
2788 Process::WritePointerToMemory (lldb::addr_t vm_addr,
2789                                lldb::addr_t ptr_value,
2790                                Error &error)
2791 {
2792     Scalar scalar;
2793     const uint32_t addr_byte_size = GetAddressByteSize();
2794     if (addr_byte_size <= 4)
2795         scalar = (uint32_t)ptr_value;
2796     else
2797         scalar = ptr_value;
2798     return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size;
2799 }
2800 
2801 size_t
2802 Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error)
2803 {
2804     size_t bytes_written = 0;
2805     const uint8_t *bytes = (const uint8_t *)buf;
2806 
2807     while (bytes_written < size)
2808     {
2809         const size_t curr_size = size - bytes_written;
2810         const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written,
2811                                                          bytes + bytes_written,
2812                                                          curr_size,
2813                                                          error);
2814         bytes_written += curr_bytes_written;
2815         if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2816             break;
2817     }
2818     return bytes_written;
2819 }
2820 
2821 size_t
2822 Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
2823 {
2824 #if defined (ENABLE_MEMORY_CACHING)
2825     m_memory_cache.Flush (addr, size);
2826 #endif
2827 
2828     if (buf == NULL || size == 0)
2829         return 0;
2830 
2831     m_mod_id.BumpMemoryID();
2832 
2833     // We need to write any data that would go where any current software traps
2834     // (enabled software breakpoints) any software traps (breakpoints) that we
2835     // may have placed in our tasks memory.
2836 
2837     BreakpointSiteList bp_sites_in_range;
2838 
2839     if (m_breakpoint_site_list.FindInRange (addr, addr + size, bp_sites_in_range))
2840     {
2841         // No breakpoint sites overlap
2842         if (bp_sites_in_range.IsEmpty())
2843             return WriteMemoryPrivate (addr, buf, size, error);
2844         else
2845         {
2846             const uint8_t *ubuf = (const uint8_t *)buf;
2847             uint64_t bytes_written = 0;
2848 
2849             bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, &error](BreakpointSite *bp) -> void {
2850 
2851                 if (error.Success())
2852                 {
2853                     addr_t intersect_addr;
2854                     size_t intersect_size;
2855                     size_t opcode_offset;
2856                     const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
2857                     UNUSED_IF_ASSERT_DISABLED(intersects);
2858                     assert(intersects);
2859                     assert(addr <= intersect_addr && intersect_addr < addr + size);
2860                     assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
2861                     assert(opcode_offset + intersect_size <= bp->GetByteSize());
2862 
2863                     // Check for bytes before this breakpoint
2864                     const addr_t curr_addr = addr + bytes_written;
2865                     if (intersect_addr > curr_addr)
2866                     {
2867                         // There are some bytes before this breakpoint that we need to
2868                         // just write to memory
2869                         size_t curr_size = intersect_addr - curr_addr;
2870                         size_t curr_bytes_written = WriteMemoryPrivate (curr_addr,
2871                                                                         ubuf + bytes_written,
2872                                                                         curr_size,
2873                                                                         error);
2874                         bytes_written += curr_bytes_written;
2875                         if (curr_bytes_written != curr_size)
2876                         {
2877                             // We weren't able to write all of the requested bytes, we
2878                             // are done looping and will return the number of bytes that
2879                             // we have written so far.
2880                             if (error.Success())
2881                                 error.SetErrorToGenericError();
2882                         }
2883                     }
2884                     // Now write any bytes that would cover up any software breakpoints
2885                     // directly into the breakpoint opcode buffer
2886                     ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
2887                     bytes_written += intersect_size;
2888                 }
2889             });
2890 
2891             if (bytes_written < size)
2892                 WriteMemoryPrivate (addr + bytes_written,
2893                                     ubuf + bytes_written,
2894                                     size - bytes_written,
2895                                     error);
2896         }
2897     }
2898     else
2899     {
2900         return WriteMemoryPrivate (addr, buf, size, error);
2901     }
2902 
2903     // Write any remaining bytes after the last breakpoint if we have any left
2904     return 0; //bytes_written;
2905 }
2906 
2907 size_t
2908 Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, size_t byte_size, Error &error)
2909 {
2910     if (byte_size == UINT32_MAX)
2911         byte_size = scalar.GetByteSize();
2912     if (byte_size > 0)
2913     {
2914         uint8_t buf[32];
2915         const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error);
2916         if (mem_size > 0)
2917             return WriteMemory(addr, buf, mem_size, error);
2918         else
2919             error.SetErrorString ("failed to get scalar as memory data");
2920     }
2921     else
2922     {
2923         error.SetErrorString ("invalid scalar value");
2924     }
2925     return 0;
2926 }
2927 
2928 size_t
2929 Process::ReadScalarIntegerFromMemory (addr_t addr,
2930                                       uint32_t byte_size,
2931                                       bool is_signed,
2932                                       Scalar &scalar,
2933                                       Error &error)
2934 {
2935     uint64_t uval = 0;
2936     if (byte_size == 0)
2937     {
2938         error.SetErrorString ("byte size is zero");
2939     }
2940     else if (byte_size & (byte_size - 1))
2941     {
2942         error.SetErrorStringWithFormat ("byte size %u is not a power of 2", byte_size);
2943     }
2944     else if (byte_size <= sizeof(uval))
2945     {
2946         const size_t bytes_read = ReadMemory (addr, &uval, byte_size, error);
2947         if (bytes_read == byte_size)
2948         {
2949             DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize());
2950             lldb::offset_t offset = 0;
2951             if (byte_size <= 4)
2952                 scalar = data.GetMaxU32 (&offset, byte_size);
2953             else
2954                 scalar = data.GetMaxU64 (&offset, byte_size);
2955             if (is_signed)
2956                 scalar.SignExtend(byte_size * 8);
2957             return bytes_read;
2958         }
2959     }
2960     else
2961     {
2962         error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
2963     }
2964     return 0;
2965 }
2966 
2967 #define USE_ALLOCATE_MEMORY_CACHE 1
2968 addr_t
2969 Process::AllocateMemory(size_t size, uint32_t permissions, Error &error)
2970 {
2971     if (GetPrivateState() != eStateStopped)
2972         return LLDB_INVALID_ADDRESS;
2973 
2974 #if defined (USE_ALLOCATE_MEMORY_CACHE)
2975     return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2976 #else
2977     addr_t allocated_addr = DoAllocateMemory (size, permissions, error);
2978     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
2979     if (log)
2980         log->Printf("Process::AllocateMemory(size=%" PRIu64 ", permissions=%s) => 0x%16.16" PRIx64 " (m_stop_id = %u m_memory_id = %u)",
2981                     (uint64_t)size,
2982                     GetPermissionsAsCString (permissions),
2983                     (uint64_t)allocated_addr,
2984                     m_mod_id.GetStopID(),
2985                     m_mod_id.GetMemoryID());
2986     return allocated_addr;
2987 #endif
2988 }
2989 
2990 bool
2991 Process::CanJIT ()
2992 {
2993     if (m_can_jit == eCanJITDontKnow)
2994     {
2995         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
2996         Error err;
2997 
2998         uint64_t allocated_memory = AllocateMemory(8,
2999                                                    ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
3000                                                    err);
3001 
3002         if (err.Success())
3003         {
3004             m_can_jit = eCanJITYes;
3005             if (log)
3006                 log->Printf ("Process::%s pid %" PRIu64 " allocation test passed, CanJIT () is true", __FUNCTION__, GetID ());
3007         }
3008         else
3009         {
3010             m_can_jit = eCanJITNo;
3011             if (log)
3012                 log->Printf ("Process::%s pid %" PRIu64 " allocation test failed, CanJIT () is false: %s", __FUNCTION__, GetID (), err.AsCString ());
3013         }
3014 
3015         DeallocateMemory (allocated_memory);
3016     }
3017 
3018     return m_can_jit == eCanJITYes;
3019 }
3020 
3021 void
3022 Process::SetCanJIT (bool can_jit)
3023 {
3024     m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
3025 }
3026 
3027 void
3028 Process::SetCanRunCode (bool can_run_code)
3029 {
3030     SetCanJIT(can_run_code);
3031     m_can_interpret_function_calls = can_run_code;
3032 }
3033 
3034 Error
3035 Process::DeallocateMemory (addr_t ptr)
3036 {
3037     Error error;
3038 #if defined (USE_ALLOCATE_MEMORY_CACHE)
3039     if (!m_allocated_memory_cache.DeallocateMemory(ptr))
3040     {
3041         error.SetErrorStringWithFormat ("deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);
3042     }
3043 #else
3044     error = DoDeallocateMemory (ptr);
3045 
3046     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3047     if (log)
3048         log->Printf("Process::DeallocateMemory(addr=0x%16.16" PRIx64 ") => err = %s (m_stop_id = %u, m_memory_id = %u)",
3049                     ptr,
3050                     error.AsCString("SUCCESS"),
3051                     m_mod_id.GetStopID(),
3052                     m_mod_id.GetMemoryID());
3053 #endif
3054     return error;
3055 }
3056 
3057 
3058 ModuleSP
3059 Process::ReadModuleFromMemory (const FileSpec& file_spec,
3060                                lldb::addr_t header_addr,
3061                                size_t size_to_read)
3062 {
3063     Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
3064     if (log)
3065     {
3066         log->Printf ("Process::ReadModuleFromMemory reading %s binary from memory", file_spec.GetPath().c_str());
3067     }
3068     ModuleSP module_sp (new Module (file_spec, ArchSpec()));
3069     if (module_sp)
3070     {
3071         Error error;
3072         ObjectFile *objfile = module_sp->GetMemoryObjectFile (shared_from_this(), header_addr, error, size_to_read);
3073         if (objfile)
3074             return module_sp;
3075     }
3076     return ModuleSP();
3077 }
3078 
3079 bool
3080 Process::GetLoadAddressPermissions (lldb::addr_t load_addr, uint32_t &permissions)
3081 {
3082     MemoryRegionInfo range_info;
3083     permissions = 0;
3084     Error error (GetMemoryRegionInfo (load_addr, range_info));
3085     if (!error.Success())
3086         return false;
3087     if (range_info.GetReadable() == MemoryRegionInfo::eDontKnow
3088         || range_info.GetWritable() == MemoryRegionInfo::eDontKnow
3089         || range_info.GetExecutable() == MemoryRegionInfo::eDontKnow)
3090     {
3091         return false;
3092     }
3093 
3094     if (range_info.GetReadable() == MemoryRegionInfo::eYes)
3095         permissions |= lldb::ePermissionsReadable;
3096 
3097     if (range_info.GetWritable() == MemoryRegionInfo::eYes)
3098         permissions |= lldb::ePermissionsWritable;
3099 
3100     if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
3101         permissions |= lldb::ePermissionsExecutable;
3102 
3103     return true;
3104 }
3105 
3106 Error
3107 Process::EnableWatchpoint (Watchpoint *watchpoint, bool notify)
3108 {
3109     Error error;
3110     error.SetErrorString("watchpoints are not supported");
3111     return error;
3112 }
3113 
3114 Error
3115 Process::DisableWatchpoint (Watchpoint *watchpoint, bool notify)
3116 {
3117     Error error;
3118     error.SetErrorString("watchpoints are not supported");
3119     return error;
3120 }
3121 
3122 StateType
3123 Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp)
3124 {
3125     StateType state;
3126     // Now wait for the process to launch and return control to us, and then
3127     // call DidLaunch:
3128     while (1)
3129     {
3130         event_sp.reset();
3131         state = WaitForStateChangedEventsPrivate (timeout, event_sp);
3132 
3133         if (StateIsStoppedState(state, false))
3134             break;
3135 
3136         // If state is invalid, then we timed out
3137         if (state == eStateInvalid)
3138             break;
3139 
3140         if (event_sp)
3141             HandlePrivateEvent (event_sp);
3142     }
3143     return state;
3144 }
3145 
3146 void
3147 Process::LoadOperatingSystemPlugin(bool flush)
3148 {
3149     if (flush)
3150         m_thread_list.Clear();
3151     m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
3152     if (flush)
3153         Flush();
3154 }
3155 
3156 Error
3157 Process::Launch (ProcessLaunchInfo &launch_info)
3158 {
3159     Error error;
3160     m_abi_sp.reset();
3161     m_dyld_ap.reset();
3162     m_jit_loaders_ap.reset();
3163     m_system_runtime_ap.reset();
3164     m_os_ap.reset();
3165     m_process_input_reader.reset();
3166     m_stop_info_override_callback = NULL;
3167 
3168     Module *exe_module = m_target.GetExecutableModulePointer();
3169     if (exe_module)
3170     {
3171         char local_exec_file_path[PATH_MAX];
3172         char platform_exec_file_path[PATH_MAX];
3173         exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path));
3174         exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path));
3175         if (exe_module->GetFileSpec().Exists())
3176         {
3177             // Install anything that might need to be installed prior to launching.
3178             // For host systems, this will do nothing, but if we are connected to a
3179             // remote platform it will install any needed binaries
3180             error = GetTarget().Install(&launch_info);
3181             if (error.Fail())
3182                 return error;
3183 
3184             if (PrivateStateThreadIsValid ())
3185                 PausePrivateStateThread ();
3186 
3187             error = WillLaunch (exe_module);
3188             if (error.Success())
3189             {
3190                 const bool restarted = false;
3191                 SetPublicState (eStateLaunching, restarted);
3192                 m_should_detach = false;
3193 
3194                 if (m_public_run_lock.TrySetRunning())
3195                 {
3196                     // Now launch using these arguments.
3197                     error = DoLaunch (exe_module, launch_info);
3198                 }
3199                 else
3200                 {
3201                     // This shouldn't happen
3202                     error.SetErrorString("failed to acquire process run lock");
3203                 }
3204 
3205                 if (error.Fail())
3206                 {
3207                     if (GetID() != LLDB_INVALID_PROCESS_ID)
3208                     {
3209                         SetID (LLDB_INVALID_PROCESS_ID);
3210                         const char *error_string = error.AsCString();
3211                         if (error_string == NULL)
3212                             error_string = "launch failed";
3213                         SetExitStatus (-1, error_string);
3214                     }
3215                 }
3216                 else
3217                 {
3218                     EventSP event_sp;
3219                     TimeValue timeout_time;
3220                     timeout_time = TimeValue::Now();
3221                     timeout_time.OffsetWithSeconds(10);
3222                     StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp);
3223 
3224                     if (state == eStateInvalid || event_sp.get() == NULL)
3225                     {
3226                         // We were able to launch the process, but we failed to
3227                         // catch the initial stop.
3228                         error.SetErrorString ("failed to catch stop after launch");
3229                         SetExitStatus (0, "failed to catch stop after launch");
3230                         Destroy(false);
3231                     }
3232                     else if (state == eStateStopped || state == eStateCrashed)
3233                     {
3234 
3235                         DidLaunch ();
3236 
3237                         DynamicLoader *dyld = GetDynamicLoader ();
3238                         if (dyld)
3239                             dyld->DidLaunch();
3240 
3241                         GetJITLoaders().DidLaunch();
3242 
3243                         SystemRuntime *system_runtime = GetSystemRuntime ();
3244                         if (system_runtime)
3245                             system_runtime->DidLaunch();
3246 
3247                         LoadOperatingSystemPlugin(false);
3248 
3249                         // Note, the stop event was consumed above, but not handled. This was done
3250                         // to give DidLaunch a chance to run. The target is either stopped or crashed.
3251                         // Directly set the state.  This is done to prevent a stop message with a bunch
3252                         // of spurious output on thread status, as well as not pop a ProcessIOHandler.
3253                         SetPublicState(state, false);
3254 
3255                         if (PrivateStateThreadIsValid ())
3256                             ResumePrivateStateThread ();
3257                         else
3258                             StartPrivateStateThread ();
3259 
3260                         m_stop_info_override_callback = GetTarget().GetArchitecture().GetStopInfoOverrideCallback();
3261 
3262                         // Target was stopped at entry as was intended. Need to notify the listeners
3263                         // about it.
3264                         if (state == eStateStopped && launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
3265                             HandlePrivateEvent(event_sp);
3266                     }
3267                     else if (state == eStateExited)
3268                     {
3269                         // We exited while trying to launch somehow.  Don't call DidLaunch as that's
3270                         // not likely to work, and return an invalid pid.
3271                         HandlePrivateEvent (event_sp);
3272                     }
3273                 }
3274             }
3275         }
3276         else
3277         {
3278             error.SetErrorStringWithFormat("file doesn't exist: '%s'", local_exec_file_path);
3279         }
3280     }
3281     return error;
3282 }
3283 
3284 
3285 Error
3286 Process::LoadCore ()
3287 {
3288     Error error = DoLoadCore();
3289     if (error.Success())
3290     {
3291         Listener listener ("lldb.process.load_core_listener");
3292         HijackProcessEvents(&listener);
3293 
3294         if (PrivateStateThreadIsValid ())
3295             ResumePrivateStateThread ();
3296         else
3297             StartPrivateStateThread ();
3298 
3299         DynamicLoader *dyld = GetDynamicLoader ();
3300         if (dyld)
3301             dyld->DidAttach();
3302 
3303         GetJITLoaders().DidAttach();
3304 
3305         SystemRuntime *system_runtime = GetSystemRuntime ();
3306         if (system_runtime)
3307             system_runtime->DidAttach();
3308 
3309         m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
3310         // We successfully loaded a core file, now pretend we stopped so we can
3311         // show all of the threads in the core file and explore the crashed
3312         // state.
3313         SetPrivateState (eStateStopped);
3314 
3315         // Wait indefinitely for a stopped event since we just posted one above...
3316         lldb::EventSP event_sp;
3317         listener.WaitForEvent (NULL, event_sp);
3318         StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
3319 
3320         if (!StateIsStoppedState (state, false))
3321         {
3322             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3323             if (log)
3324                 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
3325             error.SetErrorString ("Did not get stopped event after loading the core file.");
3326         }
3327         RestoreProcessEvents ();
3328     }
3329     return error;
3330 }
3331 
3332 DynamicLoader *
3333 Process::GetDynamicLoader ()
3334 {
3335     if (m_dyld_ap.get() == NULL)
3336         m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL));
3337     return m_dyld_ap.get();
3338 }
3339 
3340 const lldb::DataBufferSP
3341 Process::GetAuxvData()
3342 {
3343     return DataBufferSP ();
3344 }
3345 
3346 JITLoaderList &
3347 Process::GetJITLoaders ()
3348 {
3349     if (!m_jit_loaders_ap)
3350     {
3351         m_jit_loaders_ap.reset(new JITLoaderList());
3352         JITLoader::LoadPlugins(this, *m_jit_loaders_ap);
3353     }
3354     return *m_jit_loaders_ap;
3355 }
3356 
3357 SystemRuntime *
3358 Process::GetSystemRuntime ()
3359 {
3360     if (m_system_runtime_ap.get() == NULL)
3361         m_system_runtime_ap.reset (SystemRuntime::FindPlugin(this));
3362     return m_system_runtime_ap.get();
3363 }
3364 
3365 Process::AttachCompletionHandler::AttachCompletionHandler (Process *process, uint32_t exec_count) :
3366     NextEventAction (process),
3367     m_exec_count (exec_count)
3368 {
3369     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3370     if (log)
3371         log->Printf ("Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32, __FUNCTION__, static_cast<void*>(process), exec_count);
3372 }
3373 
3374 Process::NextEventAction::EventActionResult
3375 Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
3376 {
3377     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3378 
3379     StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
3380     if (log)
3381         log->Printf ("Process::AttachCompletionHandler::%s called with state %s (%d)", __FUNCTION__, StateAsCString(state), static_cast<int> (state));
3382 
3383     switch (state)
3384     {
3385         case eStateAttaching:
3386             return eEventActionSuccess;
3387 
3388         case eStateRunning:
3389         case eStateConnected:
3390             return eEventActionRetry;
3391 
3392         case eStateStopped:
3393         case eStateCrashed:
3394             {
3395                 // During attach, prior to sending the eStateStopped event,
3396                 // lldb_private::Process subclasses must set the new process ID.
3397                 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
3398                 // We don't want these events to be reported, so go set the ShouldReportStop here:
3399                 m_process->GetThreadList().SetShouldReportStop (eVoteNo);
3400 
3401                 if (m_exec_count > 0)
3402                 {
3403                     --m_exec_count;
3404 
3405                     if (log)
3406                         log->Printf ("Process::AttachCompletionHandler::%s state %s: reduced remaining exec count to %" PRIu32 ", requesting resume", __FUNCTION__, StateAsCString(state), m_exec_count);
3407 
3408                     RequestResume();
3409                     return eEventActionRetry;
3410                 }
3411                 else
3412                 {
3413                     if (log)
3414                         log->Printf ("Process::AttachCompletionHandler::%s state %s: no more execs expected to start, continuing with attach", __FUNCTION__, StateAsCString(state));
3415 
3416                     m_process->CompleteAttach ();
3417                     return eEventActionSuccess;
3418                 }
3419             }
3420             break;
3421 
3422         default:
3423         case eStateExited:
3424         case eStateInvalid:
3425             break;
3426     }
3427 
3428     m_exit_string.assign ("No valid Process");
3429     return eEventActionExit;
3430 }
3431 
3432 Process::NextEventAction::EventActionResult
3433 Process::AttachCompletionHandler::HandleBeingInterrupted()
3434 {
3435     return eEventActionSuccess;
3436 }
3437 
3438 const char *
3439 Process::AttachCompletionHandler::GetExitString ()
3440 {
3441     return m_exit_string.c_str();
3442 }
3443 
3444 Listener &
3445 ProcessAttachInfo::GetListenerForProcess (Debugger &debugger)
3446 {
3447     if (m_listener_sp)
3448         return *m_listener_sp;
3449     else
3450         return debugger.GetListener();
3451 }
3452 
3453 Error
3454 Process::Attach (ProcessAttachInfo &attach_info)
3455 {
3456     m_abi_sp.reset();
3457     m_process_input_reader.reset();
3458     m_dyld_ap.reset();
3459     m_jit_loaders_ap.reset();
3460     m_system_runtime_ap.reset();
3461     m_os_ap.reset();
3462     m_stop_info_override_callback = NULL;
3463 
3464     lldb::pid_t attach_pid = attach_info.GetProcessID();
3465     Error error;
3466     if (attach_pid == LLDB_INVALID_PROCESS_ID)
3467     {
3468         char process_name[PATH_MAX];
3469 
3470         if (attach_info.GetExecutableFile().GetPath (process_name, sizeof(process_name)))
3471         {
3472             const bool wait_for_launch = attach_info.GetWaitForLaunch();
3473 
3474             if (wait_for_launch)
3475             {
3476                 error = WillAttachToProcessWithName(process_name, wait_for_launch);
3477                 if (error.Success())
3478                 {
3479                     if (m_public_run_lock.TrySetRunning())
3480                     {
3481                         m_should_detach = true;
3482                         const bool restarted = false;
3483                         SetPublicState (eStateAttaching, restarted);
3484                         // Now attach using these arguments.
3485                         error = DoAttachToProcessWithName (process_name, attach_info);
3486                     }
3487                     else
3488                     {
3489                         // This shouldn't happen
3490                         error.SetErrorString("failed to acquire process run lock");
3491                     }
3492 
3493                     if (error.Fail())
3494                     {
3495                         if (GetID() != LLDB_INVALID_PROCESS_ID)
3496                         {
3497                             SetID (LLDB_INVALID_PROCESS_ID);
3498                             if (error.AsCString() == NULL)
3499                                 error.SetErrorString("attach failed");
3500 
3501                             SetExitStatus(-1, error.AsCString());
3502                         }
3503                     }
3504                     else
3505                     {
3506                         SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3507                         StartPrivateStateThread();
3508                     }
3509                     return error;
3510                 }
3511             }
3512             else
3513             {
3514                 ProcessInstanceInfoList process_infos;
3515                 PlatformSP platform_sp (m_target.GetPlatform ());
3516 
3517                 if (platform_sp)
3518                 {
3519                     ProcessInstanceInfoMatch match_info;
3520                     match_info.GetProcessInfo() = attach_info;
3521                     match_info.SetNameMatchType (eNameMatchEquals);
3522                     platform_sp->FindProcesses (match_info, process_infos);
3523                     const uint32_t num_matches = process_infos.GetSize();
3524                     if (num_matches == 1)
3525                     {
3526                         attach_pid = process_infos.GetProcessIDAtIndex(0);
3527                         // Fall through and attach using the above process ID
3528                     }
3529                     else
3530                     {
3531                         match_info.GetProcessInfo().GetExecutableFile().GetPath (process_name, sizeof(process_name));
3532                         if (num_matches > 1)
3533                         {
3534                             StreamString s;
3535                             ProcessInstanceInfo::DumpTableHeader (s, platform_sp.get(), true, false);
3536                             for (size_t i = 0; i < num_matches; i++)
3537                             {
3538                                 process_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(s, platform_sp.get(), true, false);
3539                             }
3540                             error.SetErrorStringWithFormat ("more than one process named %s:\n%s",
3541                                                             process_name,
3542                                                             s.GetData());
3543                         }
3544                         else
3545                             error.SetErrorStringWithFormat ("could not find a process named %s", process_name);
3546                     }
3547                 }
3548                 else
3549                 {
3550                     error.SetErrorString ("invalid platform, can't find processes by name");
3551                     return error;
3552                 }
3553             }
3554         }
3555         else
3556         {
3557             error.SetErrorString ("invalid process name");
3558         }
3559     }
3560 
3561     if (attach_pid != LLDB_INVALID_PROCESS_ID)
3562     {
3563         error = WillAttachToProcessWithID(attach_pid);
3564         if (error.Success())
3565         {
3566 
3567             if (m_public_run_lock.TrySetRunning())
3568             {
3569                 // Now attach using these arguments.
3570                 m_should_detach = true;
3571                 const bool restarted = false;
3572                 SetPublicState (eStateAttaching, restarted);
3573                 error = DoAttachToProcessWithID (attach_pid, attach_info);
3574             }
3575             else
3576             {
3577                 // This shouldn't happen
3578                 error.SetErrorString("failed to acquire process run lock");
3579             }
3580 
3581             if (error.Success())
3582             {
3583 
3584                 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3585                 StartPrivateStateThread();
3586             }
3587             else
3588             {
3589                 if (GetID() != LLDB_INVALID_PROCESS_ID)
3590                     SetID (LLDB_INVALID_PROCESS_ID);
3591 
3592                 const char *error_string = error.AsCString();
3593                 if (error_string == NULL)
3594                     error_string = "attach failed";
3595 
3596                 SetExitStatus(-1, error_string);
3597             }
3598         }
3599     }
3600     return error;
3601 }
3602 
3603 void
3604 Process::CompleteAttach ()
3605 {
3606     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3607     if (log)
3608         log->Printf ("Process::%s()", __FUNCTION__);
3609 
3610     // Let the process subclass figure out at much as it can about the process
3611     // before we go looking for a dynamic loader plug-in.
3612     ArchSpec process_arch;
3613     DidAttach(process_arch);
3614 
3615     if (process_arch.IsValid())
3616     {
3617         m_target.SetArchitecture(process_arch);
3618         if (log)
3619         {
3620             const char *triple_str = process_arch.GetTriple().getTriple().c_str ();
3621             log->Printf ("Process::%s replacing process architecture with DidAttach() architecture: %s",
3622                          __FUNCTION__,
3623                          triple_str ? triple_str : "<null>");
3624         }
3625     }
3626 
3627     // We just attached.  If we have a platform, ask it for the process architecture, and if it isn't
3628     // the same as the one we've already set, switch architectures.
3629     PlatformSP platform_sp (m_target.GetPlatform ());
3630     assert (platform_sp.get());
3631     if (platform_sp)
3632     {
3633         const ArchSpec &target_arch = m_target.GetArchitecture();
3634         if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture (target_arch, false, NULL))
3635         {
3636             ArchSpec platform_arch;
3637             platform_sp = platform_sp->GetPlatformForArchitecture (target_arch, &platform_arch);
3638             if (platform_sp)
3639             {
3640                 m_target.SetPlatform (platform_sp);
3641                 m_target.SetArchitecture(platform_arch);
3642                 if (log)
3643                     log->Printf ("Process::%s switching platform to %s and architecture to %s based on info from attach", __FUNCTION__, platform_sp->GetName().AsCString (""), platform_arch.GetTriple().getTriple().c_str ());
3644             }
3645         }
3646         else if (!process_arch.IsValid())
3647         {
3648             ProcessInstanceInfo process_info;
3649             platform_sp->GetProcessInfo (GetID(), process_info);
3650             const ArchSpec &process_arch = process_info.GetArchitecture();
3651             if (process_arch.IsValid() && !m_target.GetArchitecture().IsExactMatch(process_arch))
3652             {
3653                 m_target.SetArchitecture (process_arch);
3654                 if (log)
3655                     log->Printf ("Process::%s switching architecture to %s based on info the platform retrieved for pid %" PRIu64, __FUNCTION__, process_arch.GetTriple().getTriple().c_str (), GetID ());
3656             }
3657         }
3658     }
3659 
3660     // We have completed the attach, now it is time to find the dynamic loader
3661     // plug-in
3662     DynamicLoader *dyld = GetDynamicLoader ();
3663     if (dyld)
3664     {
3665         dyld->DidAttach();
3666         if (log)
3667         {
3668             ModuleSP exe_module_sp = m_target.GetExecutableModule ();
3669             log->Printf ("Process::%s after DynamicLoader::DidAttach(), target executable is %s (using %s plugin)",
3670                          __FUNCTION__,
3671                          exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str () : "<none>",
3672                          dyld->GetPluginName().AsCString ("<unnamed>"));
3673         }
3674     }
3675 
3676     GetJITLoaders().DidAttach();
3677 
3678     SystemRuntime *system_runtime = GetSystemRuntime ();
3679     if (system_runtime)
3680     {
3681         system_runtime->DidAttach();
3682         if (log)
3683         {
3684             ModuleSP exe_module_sp = m_target.GetExecutableModule ();
3685             log->Printf ("Process::%s after SystemRuntime::DidAttach(), target executable is %s (using %s plugin)",
3686                          __FUNCTION__,
3687                          exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str () : "<none>",
3688                          system_runtime->GetPluginName().AsCString("<unnamed>"));
3689         }
3690     }
3691 
3692     m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL));
3693     // Figure out which one is the executable, and set that in our target:
3694     const ModuleList &target_modules = m_target.GetImages();
3695     Mutex::Locker modules_locker(target_modules.GetMutex());
3696     size_t num_modules = target_modules.GetSize();
3697     ModuleSP new_executable_module_sp;
3698 
3699     for (size_t i = 0; i < num_modules; i++)
3700     {
3701         ModuleSP module_sp (target_modules.GetModuleAtIndexUnlocked (i));
3702         if (module_sp && module_sp->IsExecutable())
3703         {
3704             if (m_target.GetExecutableModulePointer() != module_sp.get())
3705                 new_executable_module_sp = module_sp;
3706             break;
3707         }
3708     }
3709     if (new_executable_module_sp)
3710     {
3711         m_target.SetExecutableModule (new_executable_module_sp, false);
3712         if (log)
3713         {
3714             ModuleSP exe_module_sp = m_target.GetExecutableModule ();
3715             log->Printf ("Process::%s after looping through modules, target executable is %s",
3716                          __FUNCTION__,
3717                          exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str () : "<none>");
3718         }
3719     }
3720 
3721     m_stop_info_override_callback = process_arch.GetStopInfoOverrideCallback();
3722 }
3723 
3724 Error
3725 Process::ConnectRemote (Stream *strm, const char *remote_url)
3726 {
3727     m_abi_sp.reset();
3728     m_process_input_reader.reset();
3729 
3730     // Find the process and its architecture.  Make sure it matches the architecture
3731     // of the current Target, and if not adjust it.
3732 
3733     Error error (DoConnectRemote (strm, remote_url));
3734     if (error.Success())
3735     {
3736         if (GetID() != LLDB_INVALID_PROCESS_ID)
3737         {
3738             EventSP event_sp;
3739             StateType state = WaitForProcessStopPrivate(NULL, event_sp);
3740 
3741             if (state == eStateStopped || state == eStateCrashed)
3742             {
3743                 // If we attached and actually have a process on the other end, then
3744                 // this ended up being the equivalent of an attach.
3745                 CompleteAttach ();
3746 
3747                 // This delays passing the stopped event to listeners till
3748                 // CompleteAttach gets a chance to complete...
3749                 HandlePrivateEvent (event_sp);
3750 
3751             }
3752         }
3753 
3754         if (PrivateStateThreadIsValid ())
3755             ResumePrivateStateThread ();
3756         else
3757             StartPrivateStateThread ();
3758     }
3759     return error;
3760 }
3761 
3762 
3763 Error
3764 Process::PrivateResume ()
3765 {
3766     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_STEP));
3767     if (log)
3768         log->Printf("Process::PrivateResume() m_stop_id = %u, public state: %s private state: %s",
3769                     m_mod_id.GetStopID(),
3770                     StateAsCString(m_public_state.GetValue()),
3771                     StateAsCString(m_private_state.GetValue()));
3772 
3773     Error error (WillResume());
3774     // Tell the process it is about to resume before the thread list
3775     if (error.Success())
3776     {
3777         // Now let the thread list know we are about to resume so it
3778         // can let all of our threads know that they are about to be
3779         // resumed. Threads will each be called with
3780         // Thread::WillResume(StateType) where StateType contains the state
3781         // that they are supposed to have when the process is resumed
3782         // (suspended/running/stepping). Threads should also check
3783         // their resume signal in lldb::Thread::GetResumeSignal()
3784         // to see if they are supposed to start back up with a signal.
3785         if (m_thread_list.WillResume())
3786         {
3787             // Last thing, do the PreResumeActions.
3788             if (!RunPreResumeActions())
3789             {
3790                 error.SetErrorStringWithFormat ("Process::PrivateResume PreResumeActions failed, not resuming.");
3791             }
3792             else
3793             {
3794                 m_mod_id.BumpResumeID();
3795                 error = DoResume();
3796                 if (error.Success())
3797                 {
3798                     DidResume();
3799                     m_thread_list.DidResume();
3800                     if (log)
3801                         log->Printf ("Process thinks the process has resumed.");
3802                 }
3803             }
3804         }
3805         else
3806         {
3807             // Somebody wanted to run without running (e.g. we were faking a step from one frame of a set of inlined
3808             // frames that share the same PC to another.)  So generate a continue & a stopped event,
3809             // and let the world handle them.
3810             if (log)
3811                 log->Printf ("Process::PrivateResume() asked to simulate a start & stop.");
3812 
3813             SetPrivateState(eStateRunning);
3814             SetPrivateState(eStateStopped);
3815         }
3816     }
3817     else if (log)
3818         log->Printf ("Process::PrivateResume() got an error \"%s\".", error.AsCString("<unknown error>"));
3819     return error;
3820 }
3821 
3822 Error
3823 Process::Halt (bool clear_thread_plans)
3824 {
3825     // Don't clear the m_clear_thread_plans_on_stop, only set it to true if
3826     // in case it was already set and some thread plan logic calls halt on its
3827     // own.
3828     m_clear_thread_plans_on_stop |= clear_thread_plans;
3829 
3830     // First make sure we aren't in the middle of handling an event, or we might restart.  This is pretty weak, since
3831     // we could just straightaway get another event.  It just narrows the window...
3832     m_currently_handling_event.WaitForValueEqualTo(false);
3833 
3834 
3835     // Pause our private state thread so we can ensure no one else eats
3836     // the stop event out from under us.
3837     Listener halt_listener ("lldb.process.halt_listener");
3838     HijackPrivateProcessEvents(&halt_listener);
3839 
3840     EventSP event_sp;
3841     Error error (WillHalt());
3842 
3843     bool restored_process_events = false;
3844     if (error.Success())
3845     {
3846 
3847         bool caused_stop = false;
3848 
3849         // Ask the process subclass to actually halt our process
3850         error = DoHalt(caused_stop);
3851         if (error.Success())
3852         {
3853             if (m_public_state.GetValue() == eStateAttaching)
3854             {
3855                 // Don't hijack and eat the eStateExited as the code that was doing
3856                 // the attach will be waiting for this event...
3857                 RestorePrivateProcessEvents();
3858                 restored_process_events = true;
3859                 SetExitStatus(SIGKILL, "Cancelled async attach.");
3860                 Destroy (false);
3861             }
3862             else
3863             {
3864                 // If "caused_stop" is true, then DoHalt stopped the process. If
3865                 // "caused_stop" is false, the process was already stopped.
3866                 // If the DoHalt caused the process to stop, then we want to catch
3867                 // this event and set the interrupted bool to true before we pass
3868                 // this along so clients know that the process was interrupted by
3869                 // a halt command.
3870                 if (caused_stop)
3871                 {
3872                     // Wait for 1 second for the process to stop.
3873                     TimeValue timeout_time;
3874                     timeout_time = TimeValue::Now();
3875                     timeout_time.OffsetWithSeconds(10);
3876                     bool got_event = halt_listener.WaitForEvent (&timeout_time, event_sp);
3877                     StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
3878 
3879                     if (!got_event || state == eStateInvalid)
3880                     {
3881                         // We timeout out and didn't get a stop event...
3882                         error.SetErrorStringWithFormat ("Halt timed out. State = %s", StateAsCString(GetState()));
3883                     }
3884                     else
3885                     {
3886                         if (StateIsStoppedState (state, false))
3887                         {
3888                             // We caused the process to interrupt itself, so mark this
3889                             // as such in the stop event so clients can tell an interrupted
3890                             // process from a natural stop
3891                             ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);
3892                         }
3893                         else
3894                         {
3895                             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3896                             if (log)
3897                                 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
3898                             error.SetErrorString ("Did not get stopped event after halt.");
3899                         }
3900                     }
3901                 }
3902                 DidHalt();
3903             }
3904         }
3905     }
3906     // Resume our private state thread before we post the event (if any)
3907     if (!restored_process_events)
3908         RestorePrivateProcessEvents();
3909 
3910     // Post any event we might have consumed. If all goes well, we will have
3911     // stopped the process, intercepted the event and set the interrupted
3912     // bool in the event.  Post it to the private event queue and that will end up
3913     // correctly setting the state.
3914     if (event_sp)
3915         m_private_state_broadcaster.BroadcastEvent(event_sp);
3916 
3917     return error;
3918 }
3919 
3920 Error
3921 Process::HaltForDestroyOrDetach(lldb::EventSP &exit_event_sp)
3922 {
3923     Error error;
3924     if (m_public_state.GetValue() == eStateRunning)
3925     {
3926         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3927         if (log)
3928             log->Printf("Process::Destroy() About to halt.");
3929         error = Halt();
3930         if (error.Success())
3931         {
3932             // Consume the halt event.
3933             TimeValue timeout (TimeValue::Now());
3934             timeout.OffsetWithSeconds(1);
3935             StateType state = WaitForProcessToStop (&timeout, &exit_event_sp);
3936 
3937             // If the process exited while we were waiting for it to stop, put the exited event into
3938             // the shared pointer passed in and return.  Our caller doesn't need to do anything else, since
3939             // they don't have a process anymore...
3940 
3941             if (state == eStateExited || m_private_state.GetValue() == eStateExited)
3942             {
3943                 if (log)
3944                     log->Printf("Process::HaltForDestroyOrDetach() Process exited while waiting to Halt.");
3945                 return error;
3946             }
3947             else
3948                 exit_event_sp.reset(); // It is ok to consume any non-exit stop events
3949 
3950             if (state != eStateStopped)
3951             {
3952                 if (log)
3953                     log->Printf("Process::HaltForDestroyOrDetach() Halt failed to stop, state is: %s", StateAsCString(state));
3954                 // If we really couldn't stop the process then we should just error out here, but if the
3955                 // lower levels just bobbled sending the event and we really are stopped, then continue on.
3956                 StateType private_state = m_private_state.GetValue();
3957                 if (private_state != eStateStopped)
3958                 {
3959                     return error;
3960                 }
3961             }
3962         }
3963         else
3964         {
3965             if (log)
3966                 log->Printf("Process::HaltForDestroyOrDetach() Halt got error: %s", error.AsCString());
3967         }
3968     }
3969     return error;
3970 }
3971 
3972 Error
3973 Process::Detach (bool keep_stopped)
3974 {
3975     EventSP exit_event_sp;
3976     Error error;
3977     m_destroy_in_process = true;
3978 
3979     error = WillDetach();
3980 
3981     if (error.Success())
3982     {
3983         if (DetachRequiresHalt())
3984         {
3985             error = HaltForDestroyOrDetach (exit_event_sp);
3986             if (!error.Success())
3987             {
3988                 m_destroy_in_process = false;
3989                 return error;
3990             }
3991             else if (exit_event_sp)
3992             {
3993                 // We shouldn't need to do anything else here.  There's no process left to detach from...
3994                 StopPrivateStateThread();
3995                 m_destroy_in_process = false;
3996                 return error;
3997             }
3998         }
3999 
4000         m_thread_list.DiscardThreadPlans();
4001         DisableAllBreakpointSites();
4002 
4003         error = DoDetach(keep_stopped);
4004         if (error.Success())
4005         {
4006             DidDetach();
4007             StopPrivateStateThread();
4008         }
4009         else
4010         {
4011             return error;
4012         }
4013     }
4014     m_destroy_in_process = false;
4015 
4016     // If we exited when we were waiting for a process to stop, then
4017     // forward the event here so we don't lose the event
4018     if (exit_event_sp)
4019     {
4020         // Directly broadcast our exited event because we shut down our
4021         // private state thread above
4022         BroadcastEvent(exit_event_sp);
4023     }
4024 
4025     // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
4026     // the last events through the event system, in which case we might strand the write lock.  Unlock
4027     // it here so when we do to tear down the process we don't get an error destroying the lock.
4028 
4029     m_public_run_lock.SetStopped();
4030     return error;
4031 }
4032 
4033 Error
4034 Process::Destroy (bool force_kill)
4035 {
4036 
4037     // Tell ourselves we are in the process of destroying the process, so that we don't do any unnecessary work
4038     // that might hinder the destruction.  Remember to set this back to false when we are done.  That way if the attempt
4039     // failed and the process stays around for some reason it won't be in a confused state.
4040 
4041     if (force_kill)
4042         m_should_detach = false;
4043 
4044     if (GetShouldDetach())
4045     {
4046         // FIXME: This will have to be a process setting:
4047         bool keep_stopped = false;
4048         Detach(keep_stopped);
4049     }
4050 
4051     m_destroy_in_process = true;
4052 
4053     Error error (WillDestroy());
4054     if (error.Success())
4055     {
4056         EventSP exit_event_sp;
4057         if (DestroyRequiresHalt())
4058         {
4059             error = HaltForDestroyOrDetach(exit_event_sp);
4060         }
4061 
4062         if (m_public_state.GetValue() != eStateRunning)
4063         {
4064             // Ditch all thread plans, and remove all our breakpoints: in case we have to restart the target to
4065             // kill it, we don't want it hitting a breakpoint...
4066             // Only do this if we've stopped, however, since if we didn't manage to halt it above, then
4067             // we're not going to have much luck doing this now.
4068             m_thread_list.DiscardThreadPlans();
4069             DisableAllBreakpointSites();
4070         }
4071 
4072         error = DoDestroy();
4073         if (error.Success())
4074         {
4075             DidDestroy();
4076             StopPrivateStateThread();
4077         }
4078         m_stdio_communication.Disconnect();
4079         m_stdio_communication.StopReadThread();
4080         m_stdin_forward = false;
4081 
4082         if (m_process_input_reader)
4083         {
4084             m_process_input_reader->SetIsDone(true);
4085             m_process_input_reader->Cancel();
4086             m_process_input_reader.reset();
4087         }
4088 
4089         // If we exited when we were waiting for a process to stop, then
4090         // forward the event here so we don't lose the event
4091         if (exit_event_sp)
4092         {
4093             // Directly broadcast our exited event because we shut down our
4094             // private state thread above
4095             BroadcastEvent(exit_event_sp);
4096         }
4097 
4098         // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
4099         // the last events through the event system, in which case we might strand the write lock.  Unlock
4100         // it here so when we do to tear down the process we don't get an error destroying the lock.
4101         m_public_run_lock.SetStopped();
4102     }
4103 
4104     m_destroy_in_process = false;
4105 
4106     return error;
4107 }
4108 
4109 Error
4110 Process::Signal (int signal)
4111 {
4112     Error error (WillSignal());
4113     if (error.Success())
4114     {
4115         error = DoSignal(signal);
4116         if (error.Success())
4117             DidSignal();
4118     }
4119     return error;
4120 }
4121 
4122 void
4123 Process::SetUnixSignals (const UnixSignalsSP &signals_sp)
4124 {
4125     assert (signals_sp && "null signals_sp");
4126     m_unix_signals_sp = signals_sp;
4127 }
4128 
4129 const lldb::UnixSignalsSP &
4130 Process::GetUnixSignals ()
4131 {
4132     assert (m_unix_signals_sp && "null m_unix_signals_sp");
4133     return m_unix_signals_sp;
4134 }
4135 
4136 lldb::ByteOrder
4137 Process::GetByteOrder () const
4138 {
4139     return m_target.GetArchitecture().GetByteOrder();
4140 }
4141 
4142 uint32_t
4143 Process::GetAddressByteSize () const
4144 {
4145     return m_target.GetArchitecture().GetAddressByteSize();
4146 }
4147 
4148 
4149 bool
4150 Process::ShouldBroadcastEvent (Event *event_ptr)
4151 {
4152     const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr);
4153     bool return_value = true;
4154     Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS | LIBLLDB_LOG_PROCESS));
4155 
4156     switch (state)
4157     {
4158         case eStateDetached:
4159         case eStateExited:
4160         case eStateUnloaded:
4161             m_stdio_communication.SynchronizeWithReadThread();
4162             // fall-through
4163         case eStateConnected:
4164         case eStateAttaching:
4165         case eStateLaunching:
4166             // These events indicate changes in the state of the debugging session, always report them.
4167             return_value = true;
4168             break;
4169         case eStateInvalid:
4170             // We stopped for no apparent reason, don't report it.
4171             return_value = false;
4172             break;
4173         case eStateRunning:
4174         case eStateStepping:
4175             // If we've started the target running, we handle the cases where we
4176             // are already running and where there is a transition from stopped to
4177             // running differently.
4178             // running -> running: Automatically suppress extra running events
4179             // stopped -> running: Report except when there is one or more no votes
4180             //     and no yes votes.
4181             SynchronouslyNotifyStateChanged (state);
4182             if (m_force_next_event_delivery)
4183                 return_value = true;
4184             else
4185             {
4186                 switch (m_last_broadcast_state)
4187                 {
4188                     case eStateRunning:
4189                     case eStateStepping:
4190                         // We always suppress multiple runnings with no PUBLIC stop in between.
4191                         return_value = false;
4192                         break;
4193                     default:
4194                         // TODO: make this work correctly. For now always report
4195                         // run if we aren't running so we don't miss any running
4196                         // events. If I run the lldb/test/thread/a.out file and
4197                         // break at main.cpp:58, run and hit the breakpoints on
4198                         // multiple threads, then somehow during the stepping over
4199                         // of all breakpoints no run gets reported.
4200 
4201                         // This is a transition from stop to run.
4202                         switch (m_thread_list.ShouldReportRun (event_ptr))
4203                         {
4204                             case eVoteYes:
4205                             case eVoteNoOpinion:
4206                                 return_value = true;
4207                                 break;
4208                             case eVoteNo:
4209                                 return_value = false;
4210                                 break;
4211                         }
4212                         break;
4213                 }
4214             }
4215             break;
4216         case eStateStopped:
4217         case eStateCrashed:
4218         case eStateSuspended:
4219         {
4220             // We've stopped.  First see if we're going to restart the target.
4221             // If we are going to stop, then we always broadcast the event.
4222             // If we aren't going to stop, let the thread plans decide if we're going to report this event.
4223             // If no thread has an opinion, we don't report it.
4224 
4225             m_stdio_communication.SynchronizeWithReadThread();
4226             RefreshStateAfterStop ();
4227             if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
4228             {
4229                 if (log)
4230                     log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s",
4231                                  static_cast<void*>(event_ptr),
4232                                  StateAsCString(state));
4233                 // Even though we know we are going to stop, we should let the threads have a look at the stop,
4234                 // so they can properly set their state.
4235                 m_thread_list.ShouldStop (event_ptr);
4236                 return_value = true;
4237             }
4238             else
4239             {
4240                 bool was_restarted = ProcessEventData::GetRestartedFromEvent (event_ptr);
4241                 bool should_resume = false;
4242 
4243                 // It makes no sense to ask "ShouldStop" if we've already been restarted...
4244                 // Asking the thread list is also not likely to go well, since we are running again.
4245                 // So in that case just report the event.
4246 
4247                 if (!was_restarted)
4248                     should_resume = m_thread_list.ShouldStop (event_ptr) == false;
4249 
4250                 if (was_restarted || should_resume || m_resume_requested)
4251                 {
4252                     Vote stop_vote = m_thread_list.ShouldReportStop (event_ptr);
4253                     if (log)
4254                         log->Printf ("Process::ShouldBroadcastEvent: should_stop: %i state: %s was_restarted: %i stop_vote: %d.",
4255                                      should_resume, StateAsCString(state),
4256                                      was_restarted, stop_vote);
4257 
4258                     switch (stop_vote)
4259                     {
4260                         case eVoteYes:
4261                             return_value = true;
4262                             break;
4263                         case eVoteNoOpinion:
4264                         case eVoteNo:
4265                             return_value = false;
4266                             break;
4267                     }
4268 
4269                     if (!was_restarted)
4270                     {
4271                         if (log)
4272                             log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s",
4273                                          static_cast<void*>(event_ptr),
4274                                          StateAsCString(state));
4275                         ProcessEventData::SetRestartedInEvent(event_ptr, true);
4276                         PrivateResume ();
4277                     }
4278 
4279                 }
4280                 else
4281                 {
4282                     return_value = true;
4283                     SynchronouslyNotifyStateChanged (state);
4284                 }
4285             }
4286         }
4287         break;
4288     }
4289 
4290     // Forcing the next event delivery is a one shot deal.  So reset it here.
4291     m_force_next_event_delivery = false;
4292 
4293     // We do some coalescing of events (for instance two consecutive running events get coalesced.)
4294     // But we only coalesce against events we actually broadcast.  So we use m_last_broadcast_state
4295     // to track that.  NB - you can't use "m_public_state.GetValue()" for that purpose, as was originally done,
4296     // because the PublicState reflects the last event pulled off the queue, and there may be several
4297     // events stacked up on the queue unserviced.  So the PublicState may not reflect the last broadcasted event
4298     // yet.  m_last_broadcast_state gets updated here.
4299 
4300     if (return_value)
4301         m_last_broadcast_state = state;
4302 
4303     if (log)
4304         log->Printf ("Process::ShouldBroadcastEvent (%p) => new state: %s, last broadcast state: %s - %s",
4305                      static_cast<void*>(event_ptr), StateAsCString(state),
4306                      StateAsCString(m_last_broadcast_state),
4307                      return_value ? "YES" : "NO");
4308     return return_value;
4309 }
4310 
4311 
4312 bool
4313 Process::StartPrivateStateThread (bool is_secondary_thread)
4314 {
4315     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
4316 
4317     bool already_running = PrivateStateThreadIsValid ();
4318     if (log)
4319         log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread");
4320 
4321     if (!is_secondary_thread && already_running)
4322         return true;
4323 
4324     // Create a thread that watches our internal state and controls which
4325     // events make it to clients (into the DCProcess event queue).
4326     char thread_name[1024];
4327 
4328     if (HostInfo::GetMaxThreadNameLength() <= 30)
4329     {
4330         // On platforms with abbreviated thread name lengths, choose thread names that fit within the limit.
4331         if (already_running)
4332             snprintf(thread_name, sizeof(thread_name), "intern-state-OV");
4333         else
4334             snprintf(thread_name, sizeof(thread_name), "intern-state");
4335     }
4336     else
4337     {
4338         if (already_running)
4339             snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state-override(pid=%" PRIu64 ")>", GetID());
4340         else
4341             snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
4342     }
4343 
4344     // Create the private state thread, and start it running.
4345     PrivateStateThreadArgs args = {this, is_secondary_thread};
4346     m_private_state_thread = ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread, (void *) &args, NULL);
4347     if (m_private_state_thread.IsJoinable())
4348     {
4349         ResumePrivateStateThread();
4350         return true;
4351     }
4352     else
4353         return false;
4354 }
4355 
4356 void
4357 Process::PausePrivateStateThread ()
4358 {
4359     ControlPrivateStateThread (eBroadcastInternalStateControlPause);
4360 }
4361 
4362 void
4363 Process::ResumePrivateStateThread ()
4364 {
4365     ControlPrivateStateThread (eBroadcastInternalStateControlResume);
4366 }
4367 
4368 void
4369 Process::StopPrivateStateThread ()
4370 {
4371     if (PrivateStateThreadIsValid ())
4372         ControlPrivateStateThread (eBroadcastInternalStateControlStop);
4373     else
4374     {
4375         Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
4376         if (log)
4377             log->Printf ("Went to stop the private state thread, but it was already invalid.");
4378     }
4379 }
4380 
4381 void
4382 Process::ControlPrivateStateThread (uint32_t signal)
4383 {
4384     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
4385 
4386     assert (signal == eBroadcastInternalStateControlStop ||
4387             signal == eBroadcastInternalStateControlPause ||
4388             signal == eBroadcastInternalStateControlResume);
4389 
4390     if (log)
4391         log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
4392 
4393     // Signal the private state thread. First we should copy this is case the
4394     // thread starts exiting since the private state thread will NULL this out
4395     // when it exits
4396     HostThread private_state_thread(m_private_state_thread);
4397     if (private_state_thread.IsJoinable())
4398     {
4399         TimeValue timeout_time;
4400         bool timed_out;
4401 
4402         m_private_state_control_broadcaster.BroadcastEvent (signal, NULL);
4403 
4404         timeout_time = TimeValue::Now();
4405         timeout_time.OffsetWithSeconds(2);
4406         if (log)
4407             log->Printf ("Sending control event of type: %d.", signal);
4408         m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out);
4409         m_private_state_control_wait.SetValue (false, eBroadcastNever);
4410 
4411         if (signal == eBroadcastInternalStateControlStop)
4412         {
4413             if (timed_out)
4414             {
4415                 Error error = private_state_thread.Cancel();
4416                 if (log)
4417                     log->Printf ("Timed out responding to the control event, cancel got error: \"%s\".", error.AsCString());
4418             }
4419             else
4420             {
4421                 if (log)
4422                     log->Printf ("The control event killed the private state thread without having to cancel.");
4423             }
4424 
4425             thread_result_t result = NULL;
4426             private_state_thread.Join(&result);
4427             m_private_state_thread.Reset();
4428         }
4429     }
4430     else
4431     {
4432         if (log)
4433             log->Printf ("Private state thread already dead, no need to signal it to stop.");
4434     }
4435 }
4436 
4437 void
4438 Process::SendAsyncInterrupt ()
4439 {
4440     if (PrivateStateThreadIsValid())
4441         m_private_state_broadcaster.BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
4442     else
4443         BroadcastEvent (Process::eBroadcastBitInterrupt, NULL);
4444 }
4445 
4446 void
4447 Process::HandlePrivateEvent (EventSP &event_sp)
4448 {
4449     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
4450     m_resume_requested = false;
4451 
4452     m_currently_handling_event.SetValue(true, eBroadcastNever);
4453 
4454     const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4455 
4456     // First check to see if anybody wants a shot at this event:
4457     if (m_next_event_action_ap.get() != NULL)
4458     {
4459         NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp);
4460         if (log)
4461             log->Printf ("Ran next event action, result was %d.", action_result);
4462 
4463         switch (action_result)
4464         {
4465             case NextEventAction::eEventActionSuccess:
4466                 SetNextEventAction(NULL);
4467                 break;
4468 
4469             case NextEventAction::eEventActionRetry:
4470                 break;
4471 
4472             case NextEventAction::eEventActionExit:
4473                 // Handle Exiting Here.  If we already got an exited event,
4474                 // we should just propagate it.  Otherwise, swallow this event,
4475                 // and set our state to exit so the next event will kill us.
4476                 if (new_state != eStateExited)
4477                 {
4478                     // FIXME: should cons up an exited event, and discard this one.
4479                     SetExitStatus(0, m_next_event_action_ap->GetExitString());
4480                     m_currently_handling_event.SetValue(false, eBroadcastAlways);
4481                     SetNextEventAction(NULL);
4482                     return;
4483                 }
4484                 SetNextEventAction(NULL);
4485                 break;
4486         }
4487     }
4488 
4489     // See if we should broadcast this state to external clients?
4490     const bool should_broadcast = ShouldBroadcastEvent (event_sp.get());
4491 
4492     if (should_broadcast)
4493     {
4494         const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged);
4495         if (log)
4496         {
4497             log->Printf ("Process::%s (pid = %" PRIu64 ") broadcasting new state %s (old state %s) to %s",
4498                          __FUNCTION__,
4499                          GetID(),
4500                          StateAsCString(new_state),
4501                          StateAsCString (GetState ()),
4502                          is_hijacked ? "hijacked" : "public");
4503         }
4504         Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
4505         if (StateIsRunningState (new_state))
4506         {
4507             // Only push the input handler if we aren't fowarding events,
4508             // as this means the curses GUI is in use...
4509             // Or don't push it if we are launching since it will come up stopped.
4510             if (!GetTarget().GetDebugger().IsForwardingEvents() && new_state != eStateLaunching &&
4511                 new_state != eStateAttaching)
4512             {
4513                 PushProcessIOHandler ();
4514                 m_iohandler_sync.SetValue(m_iohandler_sync.GetValue()+1, eBroadcastAlways);
4515                 if (log)
4516                     log->Printf("Process::%s updated m_iohandler_sync to %d", __FUNCTION__, m_iohandler_sync.GetValue());
4517             }
4518         }
4519         else if (StateIsStoppedState(new_state, false))
4520         {
4521             if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
4522             {
4523                 // If the lldb_private::Debugger is handling the events, we don't
4524                 // want to pop the process IOHandler here, we want to do it when
4525                 // we receive the stopped event so we can carefully control when
4526                 // the process IOHandler is popped because when we stop we want to
4527                 // display some text stating how and why we stopped, then maybe some
4528                 // process/thread/frame info, and then we want the "(lldb) " prompt
4529                 // to show up. If we pop the process IOHandler here, then we will
4530                 // cause the command interpreter to become the top IOHandler after
4531                 // the process pops off and it will update its prompt right away...
4532                 // See the Debugger.cpp file where it calls the function as
4533                 // "process_sp->PopProcessIOHandler()" to see where I am talking about.
4534                 // Otherwise we end up getting overlapping "(lldb) " prompts and
4535                 // garbled output.
4536                 //
4537                 // If we aren't handling the events in the debugger (which is indicated
4538                 // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or we
4539                 // are hijacked, then we always pop the process IO handler manually.
4540                 // Hijacking happens when the internal process state thread is running
4541                 // thread plans, or when commands want to run in synchronous mode
4542                 // and they call "process->WaitForProcessToStop()". An example of something
4543                 // that will hijack the events is a simple expression:
4544                 //
4545                 //  (lldb) expr (int)puts("hello")
4546                 //
4547                 // This will cause the internal process state thread to resume and halt
4548                 // the process (and _it_ will hijack the eBroadcastBitStateChanged
4549                 // events) and we do need the IO handler to be pushed and popped
4550                 // correctly.
4551 
4552                 if (is_hijacked || m_target.GetDebugger().IsHandlingEvents() == false)
4553                     PopProcessIOHandler ();
4554             }
4555         }
4556 
4557         BroadcastEvent (event_sp);
4558     }
4559     else
4560     {
4561         if (log)
4562         {
4563             log->Printf ("Process::%s (pid = %" PRIu64 ") suppressing state %s (old state %s): should_broadcast == false",
4564                          __FUNCTION__,
4565                          GetID(),
4566                          StateAsCString(new_state),
4567                          StateAsCString (GetState ()));
4568         }
4569     }
4570     m_currently_handling_event.SetValue(false, eBroadcastAlways);
4571 }
4572 
4573 thread_result_t
4574 Process::PrivateStateThread (void *arg)
4575 {
4576     PrivateStateThreadArgs *real_args = static_cast<PrivateStateThreadArgs *> (arg);
4577     thread_result_t result = real_args->process->RunPrivateStateThread(real_args->is_secondary_thread);
4578     return result;
4579 }
4580 
4581 thread_result_t
4582 Process::RunPrivateStateThread (bool is_secondary_thread)
4583 {
4584     bool control_only = true;
4585     m_private_state_control_wait.SetValue (false, eBroadcastNever);
4586 
4587     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
4588     if (log)
4589         log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
4590                      __FUNCTION__, static_cast<void*>(this), GetID());
4591 
4592     bool exit_now = false;
4593     while (!exit_now)
4594     {
4595         EventSP event_sp;
4596         WaitForEventsPrivate (NULL, event_sp, control_only);
4597         if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
4598         {
4599             if (log)
4600                 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") got a control event: %d",
4601                              __FUNCTION__, static_cast<void*>(this), GetID(),
4602                              event_sp->GetType());
4603 
4604             switch (event_sp->GetType())
4605             {
4606             case eBroadcastInternalStateControlStop:
4607                 exit_now = true;
4608                 break;      // doing any internal state management below
4609 
4610             case eBroadcastInternalStateControlPause:
4611                 control_only = true;
4612                 break;
4613 
4614             case eBroadcastInternalStateControlResume:
4615                 control_only = false;
4616                 break;
4617             }
4618 
4619             m_private_state_control_wait.SetValue (true, eBroadcastAlways);
4620             continue;
4621         }
4622         else if (event_sp->GetType() == eBroadcastBitInterrupt)
4623         {
4624             if (m_public_state.GetValue() == eStateAttaching)
4625             {
4626                 if (log)
4627                     log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt while attaching - forwarding interrupt.",
4628                                  __FUNCTION__, static_cast<void*>(this),
4629                                  GetID());
4630                 BroadcastEvent (eBroadcastBitInterrupt, NULL);
4631             }
4632             else
4633             {
4634                 if (log)
4635                     log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt - Halting.",
4636                                  __FUNCTION__, static_cast<void*>(this),
4637                                  GetID());
4638                 Halt();
4639             }
4640             continue;
4641         }
4642 
4643         const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4644 
4645         if (internal_state != eStateInvalid)
4646         {
4647             if (m_clear_thread_plans_on_stop &&
4648                 StateIsStoppedState(internal_state, true))
4649             {
4650                 m_clear_thread_plans_on_stop = false;
4651                 m_thread_list.DiscardThreadPlans();
4652             }
4653             HandlePrivateEvent (event_sp);
4654         }
4655 
4656         if (internal_state == eStateInvalid ||
4657             internal_state == eStateExited  ||
4658             internal_state == eStateDetached )
4659         {
4660             if (log)
4661                 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") about to exit with internal state %s...",
4662                              __FUNCTION__, static_cast<void*>(this), GetID(),
4663                              StateAsCString(internal_state));
4664 
4665             break;
4666         }
4667     }
4668 
4669     // Verify log is still enabled before attempting to write to it...
4670     if (log)
4671         log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
4672                      __FUNCTION__, static_cast<void*>(this), GetID());
4673 
4674     // If we are a secondary thread, then the primary thread we are working for will have already
4675     // acquired the public_run_lock, and isn't done with what it was doing yet, so don't
4676     // try to change it on the way out.
4677     if (!is_secondary_thread)
4678         m_public_run_lock.SetStopped();
4679     m_private_state_control_wait.SetValue (true, eBroadcastAlways);
4680     m_private_state_thread.Reset();
4681     return NULL;
4682 }
4683 
4684 //------------------------------------------------------------------
4685 // Process Event Data
4686 //------------------------------------------------------------------
4687 
4688 Process::ProcessEventData::ProcessEventData () :
4689     EventData (),
4690     m_process_wp (),
4691     m_state (eStateInvalid),
4692     m_restarted (false),
4693     m_update_state (0),
4694     m_interrupted (false)
4695 {
4696 }
4697 
4698 Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) :
4699     EventData (),
4700     m_process_wp (),
4701     m_state (state),
4702     m_restarted (false),
4703     m_update_state (0),
4704     m_interrupted (false)
4705 {
4706     if (process_sp)
4707         m_process_wp = process_sp;
4708 }
4709 
4710 Process::ProcessEventData::~ProcessEventData()
4711 {
4712 }
4713 
4714 const ConstString &
4715 Process::ProcessEventData::GetFlavorString ()
4716 {
4717     static ConstString g_flavor ("Process::ProcessEventData");
4718     return g_flavor;
4719 }
4720 
4721 const ConstString &
4722 Process::ProcessEventData::GetFlavor () const
4723 {
4724     return ProcessEventData::GetFlavorString ();
4725 }
4726 
4727 void
4728 Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
4729 {
4730     ProcessSP process_sp(m_process_wp.lock());
4731 
4732     if (!process_sp)
4733         return;
4734 
4735     // This function gets called twice for each event, once when the event gets pulled
4736     // off of the private process event queue, and then any number of times, first when it gets pulled off of
4737     // the public event queue, then other times when we're pretending that this is where we stopped at the
4738     // end of expression evaluation.  m_update_state is used to distinguish these
4739     // three cases; it is 0 when we're just pulling it off for private handling,
4740     // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
4741     if (m_update_state != 1)
4742         return;
4743 
4744     process_sp->SetPublicState (m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
4745 
4746     // If this is a halt event, even if the halt stopped with some reason other than a plain interrupt (e.g. we had
4747     // already stopped for a breakpoint when the halt request came through) don't do the StopInfo actions, as they may
4748     // end up restarting the process.
4749     if (m_interrupted)
4750         return;
4751 
4752     // If we're stopped and haven't restarted, then do the StopInfo actions here:
4753     if (m_state == eStateStopped && ! m_restarted)
4754     {
4755         // Let process subclasses know we are about to do a public stop and
4756         // do anything they might need to in order to speed up register and
4757         // memory accesses.
4758         process_sp->WillPublicStop();
4759 
4760         ThreadList &curr_thread_list = process_sp->GetThreadList();
4761         uint32_t num_threads = curr_thread_list.GetSize();
4762         uint32_t idx;
4763 
4764         // The actions might change one of the thread's stop_info's opinions about whether we should
4765         // stop the process, so we need to query that as we go.
4766 
4767         // One other complication here, is that we try to catch any case where the target has run (except for expressions)
4768         // and immediately exit, but if we get that wrong (which is possible) then the thread list might have changed, and
4769         // that would cause our iteration here to crash.  We could make a copy of the thread list, but we'd really like
4770         // 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
4771         // against this list & bag out if anything differs.
4772         std::vector<uint32_t> thread_index_array(num_threads);
4773         for (idx = 0; idx < num_threads; ++idx)
4774             thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
4775 
4776         // Use this to track whether we should continue from here.  We will only continue the target running if
4777         // no thread says we should stop.  Of course if some thread's PerformAction actually sets the target running,
4778         // then it doesn't matter what the other threads say...
4779 
4780         bool still_should_stop = false;
4781 
4782         // Sometimes - for instance if we have a bug in the stub we are talking to, we stop but no thread has a
4783         // valid stop reason.  In that case we should just stop, because we have no way of telling what the right
4784         // thing to do is, and it's better to let the user decide than continue behind their backs.
4785 
4786         bool does_anybody_have_an_opinion = false;
4787 
4788         for (idx = 0; idx < num_threads; ++idx)
4789         {
4790             curr_thread_list = process_sp->GetThreadList();
4791             if (curr_thread_list.GetSize() != num_threads)
4792             {
4793                 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
4794                 if (log)
4795                     log->Printf("Number of threads changed from %u to %u while processing event.", num_threads, curr_thread_list.GetSize());
4796                 break;
4797             }
4798 
4799             lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
4800 
4801             if (thread_sp->GetIndexID() != thread_index_array[idx])
4802             {
4803                 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
4804                 if (log)
4805                     log->Printf("The thread at position %u changed from %u to %u while processing event.",
4806                                 idx,
4807                                 thread_index_array[idx],
4808                                 thread_sp->GetIndexID());
4809                 break;
4810             }
4811 
4812             StopInfoSP stop_info_sp = thread_sp->GetStopInfo ();
4813             if (stop_info_sp && stop_info_sp->IsValid())
4814             {
4815                 does_anybody_have_an_opinion = true;
4816                 bool this_thread_wants_to_stop;
4817                 if (stop_info_sp->GetOverrideShouldStop())
4818                 {
4819                     this_thread_wants_to_stop = stop_info_sp->GetOverriddenShouldStopValue();
4820                 }
4821                 else
4822                 {
4823                     stop_info_sp->PerformAction(event_ptr);
4824                     // The stop action might restart the target.  If it does, then we want to mark that in the
4825                     // event so that whoever is receiving it will know to wait for the running event and reflect
4826                     // that state appropriately.
4827                     // We also need to stop processing actions, since they aren't expecting the target to be running.
4828 
4829                     // FIXME: we might have run.
4830                     if (stop_info_sp->HasTargetRunSinceMe())
4831                     {
4832                         SetRestarted (true);
4833                         break;
4834                     }
4835 
4836                     this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
4837                 }
4838 
4839                 if (still_should_stop == false)
4840                     still_should_stop = this_thread_wants_to_stop;
4841             }
4842         }
4843 
4844 
4845         if (!GetRestarted())
4846         {
4847             if (!still_should_stop && does_anybody_have_an_opinion)
4848             {
4849                 // We've been asked to continue, so do that here.
4850                 SetRestarted(true);
4851                 // Use the public resume method here, since this is just
4852                 // extending a public resume.
4853                 process_sp->PrivateResume();
4854             }
4855             else
4856             {
4857                 // If we didn't restart, run the Stop Hooks here:
4858                 // They might also restart the target, so watch for that.
4859                 process_sp->GetTarget().RunStopHooks();
4860                 if (process_sp->GetPrivateState() == eStateRunning)
4861                     SetRestarted(true);
4862             }
4863         }
4864     }
4865 }
4866 
4867 void
4868 Process::ProcessEventData::Dump (Stream *s) const
4869 {
4870     ProcessSP process_sp(m_process_wp.lock());
4871 
4872     if (process_sp)
4873         s->Printf(" process = %p (pid = %" PRIu64 "), ",
4874                   static_cast<void*>(process_sp.get()), process_sp->GetID());
4875     else
4876         s->PutCString(" process = NULL, ");
4877 
4878     s->Printf("state = %s", StateAsCString(GetState()));
4879 }
4880 
4881 const Process::ProcessEventData *
4882 Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr)
4883 {
4884     if (event_ptr)
4885     {
4886         const EventData *event_data = event_ptr->GetData();
4887         if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString())
4888             return static_cast <const ProcessEventData *> (event_ptr->GetData());
4889     }
4890     return NULL;
4891 }
4892 
4893 ProcessSP
4894 Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr)
4895 {
4896     ProcessSP process_sp;
4897     const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4898     if (data)
4899         process_sp = data->GetProcessSP();
4900     return process_sp;
4901 }
4902 
4903 StateType
4904 Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr)
4905 {
4906     const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4907     if (data == NULL)
4908         return eStateInvalid;
4909     else
4910         return data->GetState();
4911 }
4912 
4913 bool
4914 Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr)
4915 {
4916     const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4917     if (data == NULL)
4918         return false;
4919     else
4920         return data->GetRestarted();
4921 }
4922 
4923 void
4924 Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value)
4925 {
4926     ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4927     if (data != NULL)
4928         data->SetRestarted(new_value);
4929 }
4930 
4931 size_t
4932 Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr)
4933 {
4934     ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4935     if (data != NULL)
4936         return data->GetNumRestartedReasons();
4937     else
4938         return 0;
4939 }
4940 
4941 const char *
4942 Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr, size_t idx)
4943 {
4944     ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4945     if (data != NULL)
4946         return data->GetRestartedReasonAtIndex(idx);
4947     else
4948         return NULL;
4949 }
4950 
4951 void
4952 Process::ProcessEventData::AddRestartedReason (Event *event_ptr, const char *reason)
4953 {
4954     ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4955     if (data != NULL)
4956         data->AddRestartedReason(reason);
4957 }
4958 
4959 bool
4960 Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr)
4961 {
4962     const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4963     if (data == NULL)
4964         return false;
4965     else
4966         return data->GetInterrupted ();
4967 }
4968 
4969 void
4970 Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value)
4971 {
4972     ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4973     if (data != NULL)
4974         data->SetInterrupted(new_value);
4975 }
4976 
4977 bool
4978 Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr)
4979 {
4980     ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4981     if (data)
4982     {
4983         data->SetUpdateStateOnRemoval();
4984         return true;
4985     }
4986     return false;
4987 }
4988 
4989 lldb::TargetSP
4990 Process::CalculateTarget ()
4991 {
4992     return m_target.shared_from_this();
4993 }
4994 
4995 void
4996 Process::CalculateExecutionContext (ExecutionContext &exe_ctx)
4997 {
4998     exe_ctx.SetTargetPtr (&m_target);
4999     exe_ctx.SetProcessPtr (this);
5000     exe_ctx.SetThreadPtr(NULL);
5001     exe_ctx.SetFramePtr (NULL);
5002 }
5003 
5004 //uint32_t
5005 //Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
5006 //{
5007 //    return 0;
5008 //}
5009 //
5010 //ArchSpec
5011 //Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
5012 //{
5013 //    return Host::GetArchSpecForExistingProcess (pid);
5014 //}
5015 //
5016 //ArchSpec
5017 //Process::GetArchSpecForExistingProcess (const char *process_name)
5018 //{
5019 //    return Host::GetArchSpecForExistingProcess (process_name);
5020 //}
5021 //
5022 void
5023 Process::AppendSTDOUT (const char * s, size_t len)
5024 {
5025     Mutex::Locker locker (m_stdio_communication_mutex);
5026     m_stdout_data.append (s, len);
5027     BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (shared_from_this(), GetState()));
5028 }
5029 
5030 void
5031 Process::AppendSTDERR (const char * s, size_t len)
5032 {
5033     Mutex::Locker locker (m_stdio_communication_mutex);
5034     m_stderr_data.append (s, len);
5035     BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (shared_from_this(), GetState()));
5036 }
5037 
5038 void
5039 Process::BroadcastAsyncProfileData(const std::string &one_profile_data)
5040 {
5041     Mutex::Locker locker (m_profile_data_comm_mutex);
5042     m_profile_data.push_back(one_profile_data);
5043     BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState()));
5044 }
5045 
5046 size_t
5047 Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
5048 {
5049     Mutex::Locker locker(m_profile_data_comm_mutex);
5050     if (m_profile_data.empty())
5051         return 0;
5052 
5053     std::string &one_profile_data = m_profile_data.front();
5054     size_t bytes_available = one_profile_data.size();
5055     if (bytes_available > 0)
5056     {
5057         Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
5058         if (log)
5059             log->Printf ("Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
5060                          static_cast<void*>(buf),
5061                          static_cast<uint64_t>(buf_size));
5062         if (bytes_available > buf_size)
5063         {
5064             memcpy(buf, one_profile_data.c_str(), buf_size);
5065             one_profile_data.erase(0, buf_size);
5066             bytes_available = buf_size;
5067         }
5068         else
5069         {
5070             memcpy(buf, one_profile_data.c_str(), bytes_available);
5071             m_profile_data.erase(m_profile_data.begin());
5072         }
5073     }
5074     return bytes_available;
5075 }
5076 
5077 
5078 //------------------------------------------------------------------
5079 // Process STDIO
5080 //------------------------------------------------------------------
5081 
5082 size_t
5083 Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
5084 {
5085     Mutex::Locker locker(m_stdio_communication_mutex);
5086     size_t bytes_available = m_stdout_data.size();
5087     if (bytes_available > 0)
5088     {
5089         Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
5090         if (log)
5091             log->Printf ("Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
5092                          static_cast<void*>(buf),
5093                          static_cast<uint64_t>(buf_size));
5094         if (bytes_available > buf_size)
5095         {
5096             memcpy(buf, m_stdout_data.c_str(), buf_size);
5097             m_stdout_data.erase(0, buf_size);
5098             bytes_available = buf_size;
5099         }
5100         else
5101         {
5102             memcpy(buf, m_stdout_data.c_str(), bytes_available);
5103             m_stdout_data.clear();
5104         }
5105     }
5106     return bytes_available;
5107 }
5108 
5109 
5110 size_t
5111 Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
5112 {
5113     Mutex::Locker locker(m_stdio_communication_mutex);
5114     size_t bytes_available = m_stderr_data.size();
5115     if (bytes_available > 0)
5116     {
5117         Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
5118         if (log)
5119             log->Printf ("Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
5120                          static_cast<void*>(buf),
5121                          static_cast<uint64_t>(buf_size));
5122         if (bytes_available > buf_size)
5123         {
5124             memcpy(buf, m_stderr_data.c_str(), buf_size);
5125             m_stderr_data.erase(0, buf_size);
5126             bytes_available = buf_size;
5127         }
5128         else
5129         {
5130             memcpy(buf, m_stderr_data.c_str(), bytes_available);
5131             m_stderr_data.clear();
5132         }
5133     }
5134     return bytes_available;
5135 }
5136 
5137 void
5138 Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
5139 {
5140     Process *process = (Process *) baton;
5141     process->AppendSTDOUT (static_cast<const char *>(src), src_len);
5142 }
5143 
5144 class IOHandlerProcessSTDIO :
5145     public IOHandler
5146 {
5147 public:
5148     IOHandlerProcessSTDIO (Process *process,
5149                            int write_fd) :
5150     IOHandler(process->GetTarget().GetDebugger(), IOHandler::Type::ProcessIO),
5151         m_process (process),
5152         m_read_file (),
5153         m_write_file (write_fd, false),
5154         m_pipe ()
5155     {
5156         m_pipe.CreateNew(false);
5157         m_read_file.SetDescriptor(GetInputFD(), false);
5158     }
5159 
5160     virtual
5161     ~IOHandlerProcessSTDIO ()
5162     {
5163 
5164     }
5165 
5166     // Each IOHandler gets to run until it is done. It should read data
5167     // from the "in" and place output into "out" and "err and return
5168     // when done.
5169     void
5170     Run () override
5171     {
5172         if (!m_read_file.IsValid() || !m_write_file.IsValid() || !m_pipe.CanRead() || !m_pipe.CanWrite())
5173         {
5174             SetIsDone(true);
5175             return;
5176         }
5177 
5178         SetIsDone(false);
5179         const int read_fd = m_read_file.GetDescriptor();
5180         TerminalState terminal_state;
5181         terminal_state.Save (read_fd, false);
5182         Terminal terminal(read_fd);
5183         terminal.SetCanonical(false);
5184         terminal.SetEcho(false);
5185 // FD_ZERO, FD_SET are not supported on windows
5186 #ifndef _WIN32
5187         const int pipe_read_fd = m_pipe.GetReadFileDescriptor();
5188         while (!GetIsDone())
5189         {
5190             fd_set read_fdset;
5191             FD_ZERO (&read_fdset);
5192             FD_SET (read_fd, &read_fdset);
5193             FD_SET (pipe_read_fd, &read_fdset);
5194             const int nfds = std::max<int>(read_fd, pipe_read_fd) + 1;
5195             int num_set_fds = select (nfds, &read_fdset, NULL, NULL, NULL);
5196             if (num_set_fds < 0)
5197             {
5198                 const int select_errno = errno;
5199 
5200                 if (select_errno != EINTR)
5201                     SetIsDone(true);
5202             }
5203             else if (num_set_fds > 0)
5204             {
5205                 char ch = 0;
5206                 size_t n;
5207                 if (FD_ISSET (read_fd, &read_fdset))
5208                 {
5209                     n = 1;
5210                     if (m_read_file.Read(&ch, n).Success() && n == 1)
5211                     {
5212                         if (m_write_file.Write(&ch, n).Fail() || n != 1)
5213                             SetIsDone(true);
5214                     }
5215                     else
5216                         SetIsDone(true);
5217                 }
5218                 if (FD_ISSET (pipe_read_fd, &read_fdset))
5219                 {
5220                     size_t bytes_read;
5221                     // Consume the interrupt byte
5222                     Error error = m_pipe.Read(&ch, 1, bytes_read);
5223                     if (error.Success())
5224                     {
5225                         switch (ch)
5226                         {
5227                             case 'q':
5228                                 SetIsDone(true);
5229                                 break;
5230                             case 'i':
5231                                 if (StateIsRunningState(m_process->GetState()))
5232                                     m_process->Halt();
5233                                 break;
5234                         }
5235                     }
5236                 }
5237             }
5238         }
5239 #endif
5240         terminal_state.Restore();
5241     }
5242 
5243     void
5244     Cancel () override
5245     {
5246         char ch = 'q';  // Send 'q' for quit
5247         size_t bytes_written = 0;
5248         m_pipe.Write(&ch, 1, bytes_written);
5249     }
5250 
5251     bool
5252     Interrupt () override
5253     {
5254         // Do only things that are safe to do in an interrupt context (like in
5255         // a SIGINT handler), like write 1 byte to a file descriptor. This will
5256         // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
5257         // that was written to the pipe and then call m_process->Halt() from a
5258         // much safer location in code.
5259         if (m_active)
5260         {
5261             char ch = 'i'; // Send 'i' for interrupt
5262             size_t bytes_written = 0;
5263             Error result = m_pipe.Write(&ch, 1, bytes_written);
5264             return result.Success();
5265         }
5266         else
5267         {
5268             // This IOHandler might be pushed on the stack, but not being run currently
5269             // so do the right thing if we aren't actively watching for STDIN by sending
5270             // the interrupt to the process. Otherwise the write to the pipe above would
5271             // do nothing. This can happen when the command interpreter is running and
5272             // gets a "expression ...". It will be on the IOHandler thread and sending
5273             // the input is complete to the delegate which will cause the expression to
5274             // run, which will push the process IO handler, but not run it.
5275 
5276             if (StateIsRunningState(m_process->GetState()))
5277             {
5278                 m_process->SendAsyncInterrupt();
5279                 return true;
5280             }
5281         }
5282         return false;
5283     }
5284 
5285     void
5286     GotEOF() override
5287     {
5288 
5289     }
5290 
5291 protected:
5292     Process *m_process;
5293     File m_read_file;   // Read from this file (usually actual STDIN for LLDB
5294     File m_write_file;  // Write to this file (usually the master pty for getting io to debuggee)
5295     Pipe m_pipe;
5296 };
5297 
5298 void
5299 Process::SetSTDIOFileDescriptor (int fd)
5300 {
5301     // First set up the Read Thread for reading/handling process I/O
5302 
5303     std::unique_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (fd, true));
5304 
5305     if (conn_ap.get())
5306     {
5307         m_stdio_communication.SetConnection (conn_ap.release());
5308         if (m_stdio_communication.IsConnected())
5309         {
5310             m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
5311             m_stdio_communication.StartReadThread();
5312 
5313             // Now read thread is set up, set up input reader.
5314 
5315             if (!m_process_input_reader.get())
5316                 m_process_input_reader.reset (new IOHandlerProcessSTDIO (this, fd));
5317         }
5318     }
5319 }
5320 
5321 bool
5322 Process::ProcessIOHandlerIsActive ()
5323 {
5324     IOHandlerSP io_handler_sp (m_process_input_reader);
5325     if (io_handler_sp)
5326         return m_target.GetDebugger().IsTopIOHandler (io_handler_sp);
5327     return false;
5328 }
5329 bool
5330 Process::PushProcessIOHandler ()
5331 {
5332     IOHandlerSP io_handler_sp (m_process_input_reader);
5333     if (io_handler_sp)
5334     {
5335         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
5336         if (log)
5337             log->Printf("Process::%s pushing IO handler", __FUNCTION__);
5338 
5339         io_handler_sp->SetIsDone(false);
5340         m_target.GetDebugger().PushIOHandler (io_handler_sp);
5341         return true;
5342     }
5343     return false;
5344 }
5345 
5346 bool
5347 Process::PopProcessIOHandler ()
5348 {
5349     IOHandlerSP io_handler_sp (m_process_input_reader);
5350     if (io_handler_sp)
5351         return m_target.GetDebugger().PopIOHandler (io_handler_sp);
5352     return false;
5353 }
5354 
5355 // The process needs to know about installed plug-ins
5356 void
5357 Process::SettingsInitialize ()
5358 {
5359     Thread::SettingsInitialize ();
5360 }
5361 
5362 void
5363 Process::SettingsTerminate ()
5364 {
5365     Thread::SettingsTerminate ();
5366 }
5367 
5368 ExpressionResults
5369 Process::RunThreadPlan (ExecutionContext &exe_ctx,
5370                         lldb::ThreadPlanSP &thread_plan_sp,
5371                         const EvaluateExpressionOptions &options,
5372                         Stream &errors)
5373 {
5374     ExpressionResults return_value = eExpressionSetupError;
5375 
5376     if (thread_plan_sp.get() == NULL)
5377     {
5378         errors.Printf("RunThreadPlan called with empty thread plan.");
5379         return eExpressionSetupError;
5380     }
5381 
5382     if (!thread_plan_sp->ValidatePlan(NULL))
5383     {
5384         errors.Printf ("RunThreadPlan called with an invalid thread plan.");
5385         return eExpressionSetupError;
5386     }
5387 
5388     if (exe_ctx.GetProcessPtr() != this)
5389     {
5390         errors.Printf("RunThreadPlan called on wrong process.");
5391         return eExpressionSetupError;
5392     }
5393 
5394     Thread *thread = exe_ctx.GetThreadPtr();
5395     if (thread == NULL)
5396     {
5397         errors.Printf("RunThreadPlan called with invalid thread.");
5398         return eExpressionSetupError;
5399     }
5400 
5401     // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes.
5402     // For that to be true the plan can't be private - since private plans suppress themselves in the
5403     // GetCompletedPlan call.
5404 
5405     bool orig_plan_private = thread_plan_sp->GetPrivate();
5406     thread_plan_sp->SetPrivate(false);
5407 
5408     if (m_private_state.GetValue() != eStateStopped)
5409     {
5410         errors.Printf ("RunThreadPlan called while the private state was not stopped.");
5411         return eExpressionSetupError;
5412     }
5413 
5414     // Save the thread & frame from the exe_ctx for restoration after we run
5415     const uint32_t thread_idx_id = thread->GetIndexID();
5416     StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
5417     if (!selected_frame_sp)
5418     {
5419         thread->SetSelectedFrame(0);
5420         selected_frame_sp = thread->GetSelectedFrame();
5421         if (!selected_frame_sp)
5422         {
5423             errors.Printf("RunThreadPlan called without a selected frame on thread %d", thread_idx_id);
5424             return eExpressionSetupError;
5425         }
5426     }
5427 
5428     StackID ctx_frame_id = selected_frame_sp->GetStackID();
5429 
5430     // N.B. Running the target may unset the currently selected thread and frame.  We don't want to do that either,
5431     // so we should arrange to reset them as well.
5432 
5433     lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
5434 
5435     uint32_t selected_tid;
5436     StackID selected_stack_id;
5437     if (selected_thread_sp)
5438     {
5439         selected_tid = selected_thread_sp->GetIndexID();
5440         selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
5441     }
5442     else
5443     {
5444         selected_tid = LLDB_INVALID_THREAD_ID;
5445     }
5446 
5447     HostThread backup_private_state_thread;
5448     lldb::StateType old_state = eStateInvalid;
5449     lldb::ThreadPlanSP stopper_base_plan_sp;
5450 
5451     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
5452     if (m_private_state_thread.EqualsThread(Host::GetCurrentThread()))
5453     {
5454         // Yikes, we are running on the private state thread!  So we can't wait for public events on this thread, since
5455         // we are the thread that is generating public events.
5456         // The simplest thing to do is to spin up a temporary thread to handle private state thread events while
5457         // we are fielding public events here.
5458         if (log)
5459             log->Printf ("Running thread plan on private state thread, spinning up another state thread to handle the events.");
5460 
5461         backup_private_state_thread = m_private_state_thread;
5462 
5463         // One other bit of business: we want to run just this thread plan and anything it pushes, and then stop,
5464         // returning control here.
5465         // But in the normal course of things, the plan above us on the stack would be given a shot at the stop
5466         // event before deciding to stop, and we don't want that.  So we insert a "stopper" base plan on the stack
5467         // before the plan we want to run.  Since base plans always stop and return control to the user, that will
5468         // do just what we want.
5469         stopper_base_plan_sp.reset(new ThreadPlanBase (*thread));
5470         thread->QueueThreadPlan (stopper_base_plan_sp, false);
5471         // Have to make sure our public state is stopped, since otherwise the reporting logic below doesn't work correctly.
5472         old_state = m_public_state.GetValue();
5473         m_public_state.SetValueNoLock(eStateStopped);
5474 
5475         // Now spin up the private state thread:
5476         StartPrivateStateThread(true);
5477     }
5478 
5479     thread->QueueThreadPlan(thread_plan_sp, false); // This used to pass "true" does that make sense?
5480 
5481     if (options.GetDebug())
5482     {
5483         // In this case, we aren't actually going to run, we just want to stop right away.
5484         // Flush this thread so we will refetch the stacks and show the correct backtrace.
5485         // FIXME: To make this prettier we should invent some stop reason for this, but that
5486         // is only cosmetic, and this functionality is only of use to lldb developers who can
5487         // live with not pretty...
5488         thread->Flush();
5489         return eExpressionStoppedForDebug;
5490     }
5491 
5492     Listener listener("lldb.process.listener.run-thread-plan");
5493 
5494     lldb::EventSP event_to_broadcast_sp;
5495 
5496     {
5497         // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get
5498         // restored on exit to the function.
5499         //
5500         // If the event needs to propagate beyond the hijacker (e.g., the process exits during execution), then the event
5501         // is put into event_to_broadcast_sp for rebroadcasting.
5502 
5503         ProcessEventHijacker run_thread_plan_hijacker (*this, &listener);
5504 
5505         if (log)
5506         {
5507             StreamString s;
5508             thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
5509             log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64 " to run thread plan \"%s\".",
5510                          thread->GetIndexID(),
5511                          thread->GetID(),
5512                          s.GetData());
5513         }
5514 
5515         bool got_event;
5516         lldb::EventSP event_sp;
5517         lldb::StateType stop_state = lldb::eStateInvalid;
5518 
5519         TimeValue* timeout_ptr = NULL;
5520         TimeValue real_timeout;
5521 
5522         bool before_first_timeout = true;  // This is set to false the first time that we have to halt the target.
5523         bool do_resume = true;
5524         bool handle_running_event = true;
5525         const uint64_t default_one_thread_timeout_usec = 250000;
5526 
5527         // This is just for accounting:
5528         uint32_t num_resumes = 0;
5529 
5530         uint32_t timeout_usec = options.GetTimeoutUsec();
5531         uint32_t one_thread_timeout_usec;
5532         uint32_t all_threads_timeout_usec = 0;
5533 
5534         // If we are going to run all threads the whole time, or if we are only going to run one thread,
5535         // then we don't need the first timeout.  So we set the final timeout, and pretend we are after the
5536         // first timeout already.
5537 
5538         if (!options.GetStopOthers() || !options.GetTryAllThreads())
5539         {
5540             before_first_timeout = false;
5541             one_thread_timeout_usec = 0;
5542             all_threads_timeout_usec = timeout_usec;
5543         }
5544         else
5545         {
5546             uint32_t option_one_thread_timeout = options.GetOneThreadTimeoutUsec();
5547 
5548             // If the overall wait is forever, then we only need to set the one thread timeout:
5549             if (timeout_usec == 0)
5550             {
5551                 if (option_one_thread_timeout != 0)
5552                     one_thread_timeout_usec = option_one_thread_timeout;
5553                 else
5554                     one_thread_timeout_usec = default_one_thread_timeout_usec;
5555             }
5556             else
5557             {
5558                 // Otherwise, if the one thread timeout is set, make sure it isn't longer than the overall timeout,
5559                 // and use it, otherwise use half the total timeout, bounded by the default_one_thread_timeout_usec.
5560                 uint64_t computed_one_thread_timeout;
5561                 if (option_one_thread_timeout != 0)
5562                 {
5563                     if (timeout_usec < option_one_thread_timeout)
5564                     {
5565                         errors.Printf("RunThreadPlan called without one thread timeout greater than total timeout");
5566                         return eExpressionSetupError;
5567                     }
5568                     computed_one_thread_timeout = option_one_thread_timeout;
5569                 }
5570                 else
5571                 {
5572                     computed_one_thread_timeout = timeout_usec / 2;
5573                     if (computed_one_thread_timeout > default_one_thread_timeout_usec)
5574                         computed_one_thread_timeout = default_one_thread_timeout_usec;
5575                 }
5576                 one_thread_timeout_usec = computed_one_thread_timeout;
5577                 all_threads_timeout_usec = timeout_usec - one_thread_timeout_usec;
5578 
5579             }
5580         }
5581 
5582         if (log)
5583             log->Printf ("Stop others: %u, try all: %u, before_first: %u, one thread: %" PRIu32 " - all threads: %" PRIu32 ".\n",
5584                          options.GetStopOthers(),
5585                          options.GetTryAllThreads(),
5586                          before_first_timeout,
5587                          one_thread_timeout_usec,
5588                          all_threads_timeout_usec);
5589 
5590         // This isn't going to work if there are unfetched events on the queue.
5591         // Are there cases where we might want to run the remaining events here, and then try to
5592         // call the function?  That's probably being too tricky for our own good.
5593 
5594         Event *other_events = listener.PeekAtNextEvent();
5595         if (other_events != NULL)
5596         {
5597             errors.Printf("Calling RunThreadPlan with pending events on the queue.");
5598             return eExpressionSetupError;
5599         }
5600 
5601         // We also need to make sure that the next event is delivered.  We might be calling a function as part of
5602         // a thread plan, in which case the last delivered event could be the running event, and we don't want
5603         // event coalescing to cause us to lose OUR running event...
5604         ForceNextEventDelivery();
5605 
5606         // This while loop must exit out the bottom, there's cleanup that we need to do when we are done.
5607         // So don't call return anywhere within it.
5608 
5609 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5610         // It's pretty much impossible to write test cases for things like:
5611         // One thread timeout expires, I go to halt, but the process already stopped
5612         // on the function call stop breakpoint.  Turning on this define will make us not
5613         // fetch the first event till after the halt.  So if you run a quick function, it will have
5614         // completed, and the completion event will be waiting, when you interrupt for halt.
5615         // The expression evaluation should still succeed.
5616         bool miss_first_event = true;
5617 #endif
5618         TimeValue one_thread_timeout;
5619         TimeValue final_timeout;
5620 
5621 
5622         while (1)
5623         {
5624             // We usually want to resume the process if we get to the top of the loop.
5625             // The only exception is if we get two running events with no intervening
5626             // stop, which can happen, we will just wait for then next stop event.
5627             if (log)
5628                 log->Printf ("Top of while loop: do_resume: %i handle_running_event: %i before_first_timeout: %i.",
5629                              do_resume,
5630                              handle_running_event,
5631                              before_first_timeout);
5632 
5633             if (do_resume || handle_running_event)
5634             {
5635                 // Do the initial resume and wait for the running event before going further.
5636 
5637                 if (do_resume)
5638                 {
5639                     num_resumes++;
5640                     Error resume_error = PrivateResume ();
5641                     if (!resume_error.Success())
5642                     {
5643                         errors.Printf("Error resuming inferior the %d time: \"%s\".\n",
5644                                       num_resumes,
5645                                       resume_error.AsCString());
5646                         return_value = eExpressionSetupError;
5647                         break;
5648                     }
5649                 }
5650 
5651                 TimeValue resume_timeout = TimeValue::Now();
5652                 resume_timeout.OffsetWithMicroSeconds(500000);
5653 
5654                 got_event = listener.WaitForEvent(&resume_timeout, event_sp);
5655                 if (!got_event)
5656                 {
5657                     if (log)
5658                         log->Printf ("Process::RunThreadPlan(): didn't get any event after resume %d, exiting.",
5659                                         num_resumes);
5660 
5661                     errors.Printf("Didn't get any event after resume %d, exiting.", num_resumes);
5662                     return_value = eExpressionSetupError;
5663                     break;
5664                 }
5665 
5666                 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5667 
5668                 if (stop_state != eStateRunning)
5669                 {
5670                     bool restarted = false;
5671 
5672                     if (stop_state == eStateStopped)
5673                     {
5674                         restarted = Process::ProcessEventData::GetRestartedFromEvent(event_sp.get());
5675                         if (log)
5676                             log->Printf("Process::RunThreadPlan(): didn't get running event after "
5677                                         "resume %d, got %s instead (restarted: %i, do_resume: %i, handle_running_event: %i).",
5678                                         num_resumes,
5679                                         StateAsCString(stop_state),
5680                                         restarted,
5681                                         do_resume,
5682                                         handle_running_event);
5683                     }
5684 
5685                     if (restarted)
5686                     {
5687                         // This is probably an overabundance of caution, I don't think I should ever get a stopped & restarted
5688                         // event here.  But if I do, the best thing is to Halt and then get out of here.
5689                         Halt();
5690                     }
5691 
5692                     errors.Printf("Didn't get running event after initial resume, got %s instead.",
5693                                   StateAsCString(stop_state));
5694                     return_value = eExpressionSetupError;
5695                     break;
5696                 }
5697 
5698                 if (log)
5699                     log->PutCString ("Process::RunThreadPlan(): resuming succeeded.");
5700                 // We need to call the function synchronously, so spin waiting for it to return.
5701                 // If we get interrupted while executing, we're going to lose our context, and
5702                 // won't be able to gather the result at this point.
5703                 // We set the timeout AFTER the resume, since the resume takes some time and we
5704                 // don't want to charge that to the timeout.
5705             }
5706             else
5707             {
5708                 if (log)
5709                     log->PutCString ("Process::RunThreadPlan(): waiting for next event.");
5710             }
5711 
5712             if (before_first_timeout)
5713             {
5714                 if (options.GetTryAllThreads())
5715                 {
5716                     one_thread_timeout = TimeValue::Now();
5717                     one_thread_timeout.OffsetWithMicroSeconds(one_thread_timeout_usec);
5718                     timeout_ptr = &one_thread_timeout;
5719                 }
5720                 else
5721                 {
5722                     if (timeout_usec == 0)
5723                         timeout_ptr = NULL;
5724                     else
5725                     {
5726                         final_timeout = TimeValue::Now();
5727                         final_timeout.OffsetWithMicroSeconds (timeout_usec);
5728                         timeout_ptr = &final_timeout;
5729                     }
5730                 }
5731             }
5732             else
5733             {
5734                 if (timeout_usec == 0)
5735                     timeout_ptr = NULL;
5736                 else
5737                 {
5738                     final_timeout = TimeValue::Now();
5739                     final_timeout.OffsetWithMicroSeconds (all_threads_timeout_usec);
5740                     timeout_ptr = &final_timeout;
5741                 }
5742             }
5743 
5744             do_resume = true;
5745             handle_running_event = true;
5746 
5747             // Now wait for the process to stop again:
5748             event_sp.reset();
5749 
5750             if (log)
5751             {
5752                 if (timeout_ptr)
5753                 {
5754                     log->Printf ("Process::RunThreadPlan(): about to wait - now is %" PRIu64 " - endpoint is %" PRIu64,
5755                                  TimeValue::Now().GetAsMicroSecondsSinceJan1_1970(),
5756                                  timeout_ptr->GetAsMicroSecondsSinceJan1_1970());
5757                 }
5758                 else
5759                 {
5760                     log->Printf ("Process::RunThreadPlan(): about to wait forever.");
5761                 }
5762             }
5763 
5764 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5765             // See comment above...
5766             if (miss_first_event)
5767             {
5768                 usleep(1000);
5769                 miss_first_event = false;
5770                 got_event = false;
5771             }
5772             else
5773 #endif
5774             got_event = listener.WaitForEvent (timeout_ptr, event_sp);
5775 
5776             if (got_event)
5777             {
5778                 if (event_sp.get())
5779                 {
5780                     bool keep_going = false;
5781                     if (event_sp->GetType() == eBroadcastBitInterrupt)
5782                     {
5783                         Halt();
5784                         return_value = eExpressionInterrupted;
5785                         errors.Printf ("Execution halted by user interrupt.");
5786                         if (log)
5787                             log->Printf ("Process::RunThreadPlan(): Got  interrupted by eBroadcastBitInterrupted, exiting.");
5788                         break;
5789                     }
5790                     else
5791                     {
5792                         stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5793                         if (log)
5794                             log->Printf("Process::RunThreadPlan(): in while loop, got event: %s.", StateAsCString(stop_state));
5795 
5796                         switch (stop_state)
5797                         {
5798                         case lldb::eStateStopped:
5799                             {
5800                                 // We stopped, figure out what we are going to do now.
5801                                 ThreadSP thread_sp = GetThreadList().FindThreadByIndexID (thread_idx_id);
5802                                 if (!thread_sp)
5803                                 {
5804                                     // Ooh, our thread has vanished.  Unlikely that this was successful execution...
5805                                     if (log)
5806                                         log->Printf ("Process::RunThreadPlan(): execution completed but our thread (index-id=%u) has vanished.", thread_idx_id);
5807                                     return_value = eExpressionInterrupted;
5808                                 }
5809                                 else
5810                                 {
5811                                     // If we were restarted, we just need to go back up to fetch another event.
5812                                     if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
5813                                     {
5814                                         if (log)
5815                                         {
5816                                             log->Printf ("Process::RunThreadPlan(): Got a stop and restart, so we'll continue waiting.");
5817                                         }
5818                                        keep_going = true;
5819                                        do_resume = false;
5820                                        handle_running_event = true;
5821 
5822                                     }
5823                                     else
5824                                     {
5825                                         StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
5826                                         StopReason stop_reason = eStopReasonInvalid;
5827                                         if (stop_info_sp)
5828                                              stop_reason = stop_info_sp->GetStopReason();
5829 
5830                                         // FIXME: We only check if the stop reason is plan complete, should we make sure that
5831                                         // it is OUR plan that is complete?
5832                                         if (stop_reason == eStopReasonPlanComplete)
5833                                         {
5834                                             if (log)
5835                                                 log->PutCString ("Process::RunThreadPlan(): execution completed successfully.");
5836                                             // Now mark this plan as private so it doesn't get reported as the stop reason
5837                                             // after this point.
5838                                             if (thread_plan_sp)
5839                                                 thread_plan_sp->SetPrivate (orig_plan_private);
5840                                             return_value = eExpressionCompleted;
5841                                         }
5842                                         else
5843                                         {
5844                                             // Something restarted the target, so just wait for it to stop for real.
5845                                             if (stop_reason == eStopReasonBreakpoint)
5846                                             {
5847                                                 if (log)
5848                                                     log->Printf ("Process::RunThreadPlan() stopped for breakpoint: %s.", stop_info_sp->GetDescription());
5849                                                 return_value = eExpressionHitBreakpoint;
5850                                                 if (!options.DoesIgnoreBreakpoints())
5851                                                 {
5852                                                     event_to_broadcast_sp = event_sp;
5853                                                 }
5854                                             }
5855                                             else
5856                                             {
5857                                                 if (log)
5858                                                     log->PutCString ("Process::RunThreadPlan(): thread plan didn't successfully complete.");
5859                                                 if (!options.DoesUnwindOnError())
5860                                                     event_to_broadcast_sp = event_sp;
5861                                                 return_value = eExpressionInterrupted;
5862                                             }
5863                                         }
5864                                     }
5865                                 }
5866                             }
5867                             break;
5868 
5869                         case lldb::eStateRunning:
5870                             // This shouldn't really happen, but sometimes we do get two running events without an
5871                             // intervening stop, and in that case we should just go back to waiting for the stop.
5872                             do_resume = false;
5873                             keep_going = true;
5874                             handle_running_event = false;
5875                             break;
5876 
5877                         default:
5878                             if (log)
5879                                 log->Printf("Process::RunThreadPlan(): execution stopped with unexpected state: %s.", StateAsCString(stop_state));
5880 
5881                             if (stop_state == eStateExited)
5882                                 event_to_broadcast_sp = event_sp;
5883 
5884                             errors.Printf ("Execution stopped with unexpected state.\n");
5885                             return_value = eExpressionInterrupted;
5886                             break;
5887                         }
5888                     }
5889 
5890                     if (keep_going)
5891                         continue;
5892                     else
5893                         break;
5894                 }
5895                 else
5896                 {
5897                     if (log)
5898                         log->PutCString ("Process::RunThreadPlan(): got_event was true, but the event pointer was null.  How odd...");
5899                     return_value = eExpressionInterrupted;
5900                     break;
5901                 }
5902             }
5903             else
5904             {
5905                 // If we didn't get an event that means we've timed out...
5906                 // We will interrupt the process here.  Depending on what we were asked to do we will
5907                 // either exit, or try with all threads running for the same timeout.
5908 
5909                 if (log) {
5910                     if (options.GetTryAllThreads())
5911                     {
5912                         if (before_first_timeout)
5913                         {
5914                             if (timeout_usec != 0)
5915                             {
5916                                 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
5917                                              "running for %" PRIu32 " usec with all threads enabled.",
5918                                              all_threads_timeout_usec);
5919                             }
5920                             else
5921                             {
5922                                 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
5923                                              "running forever with all threads enabled.");
5924                             }
5925                         }
5926                         else
5927                             log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled "
5928                                          "and timeout: %u timed out, abandoning execution.",
5929                                          timeout_usec);
5930                     }
5931                     else
5932                         log->Printf ("Process::RunThreadPlan(): Running function with timeout: %u timed out, "
5933                                      "abandoning execution.",
5934                                      timeout_usec);
5935                 }
5936 
5937                 // It is possible that between the time we issued the Halt, and we get around to calling Halt the target
5938                 // could have stopped.  That's fine, Halt will figure that out and send the appropriate Stopped event.
5939                 // BUT it is also possible that we stopped & restarted (e.g. hit a signal with "stop" set to false.)  In
5940                 // that case, we'll get the stopped & restarted event, and we should go back to waiting for the Halt's
5941                 // stopped event.  That's what this while loop does.
5942 
5943                 bool back_to_top = true;
5944                 uint32_t try_halt_again = 0;
5945                 bool do_halt = true;
5946                 const uint32_t num_retries = 5;
5947                 while (try_halt_again < num_retries)
5948                 {
5949                     Error halt_error;
5950                     if (do_halt)
5951                     {
5952                         if (log)
5953                             log->Printf ("Process::RunThreadPlan(): Running Halt.");
5954                         halt_error = Halt();
5955                     }
5956                     if (halt_error.Success())
5957                     {
5958                         if (log)
5959                             log->PutCString ("Process::RunThreadPlan(): Halt succeeded.");
5960 
5961                         real_timeout = TimeValue::Now();
5962                         real_timeout.OffsetWithMicroSeconds(500000);
5963 
5964                         got_event = listener.WaitForEvent(&real_timeout, event_sp);
5965 
5966                         if (got_event)
5967                         {
5968                             stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5969                             if (log)
5970                             {
5971                                 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state));
5972                                 if (stop_state == lldb::eStateStopped
5973                                     && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
5974                                     log->PutCString ("    Event was the Halt interruption event.");
5975                             }
5976 
5977                             if (stop_state == lldb::eStateStopped)
5978                             {
5979                                 // Between the time we initiated the Halt and the time we delivered it, the process could have
5980                                 // already finished its job.  Check that here:
5981 
5982                                 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
5983                                 {
5984                                     if (log)
5985                                         log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done.  "
5986                                                      "Exiting wait loop.");
5987                                     return_value = eExpressionCompleted;
5988                                     back_to_top = false;
5989                                     break;
5990                                 }
5991 
5992                                 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
5993                                 {
5994                                     if (log)
5995                                         log->PutCString ("Process::RunThreadPlan(): Went to halt but got a restarted event, there must be an un-restarted stopped event so try again...  "
5996                                                      "Exiting wait loop.");
5997                                     try_halt_again++;
5998                                     do_halt = false;
5999                                     continue;
6000                                 }
6001 
6002                                 if (!options.GetTryAllThreads())
6003                                 {
6004                                     if (log)
6005                                         log->PutCString ("Process::RunThreadPlan(): try_all_threads was false, we stopped so now we're quitting.");
6006                                     return_value = eExpressionInterrupted;
6007                                     back_to_top = false;
6008                                     break;
6009                                 }
6010 
6011                                 if (before_first_timeout)
6012                                 {
6013                                     // Set all the other threads to run, and return to the top of the loop, which will continue;
6014                                     before_first_timeout = false;
6015                                     thread_plan_sp->SetStopOthers (false);
6016                                     if (log)
6017                                         log->PutCString ("Process::RunThreadPlan(): about to resume.");
6018 
6019                                     back_to_top = true;
6020                                     break;
6021                                 }
6022                                 else
6023                                 {
6024                                     // Running all threads failed, so return Interrupted.
6025                                     if (log)
6026                                         log->PutCString("Process::RunThreadPlan(): running all threads timed out.");
6027                                     return_value = eExpressionInterrupted;
6028                                     back_to_top = false;
6029                                     break;
6030                                 }
6031                             }
6032                         }
6033                         else
6034                         {   if (log)
6035                                 log->PutCString("Process::RunThreadPlan(): halt said it succeeded, but I got no event.  "
6036                                         "I'm getting out of here passing Interrupted.");
6037                             return_value = eExpressionInterrupted;
6038                             back_to_top = false;
6039                             break;
6040                         }
6041                     }
6042                     else
6043                     {
6044                         try_halt_again++;
6045                         continue;
6046                     }
6047                 }
6048 
6049                 if (!back_to_top || try_halt_again > num_retries)
6050                     break;
6051                 else
6052                     continue;
6053             }
6054         }  // END WAIT LOOP
6055 
6056         // If we had to start up a temporary private state thread to run this thread plan, shut it down now.
6057         if (backup_private_state_thread.IsJoinable())
6058         {
6059             StopPrivateStateThread();
6060             Error error;
6061             m_private_state_thread = backup_private_state_thread;
6062             if (stopper_base_plan_sp)
6063             {
6064                 thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
6065             }
6066             if (old_state != eStateInvalid)
6067                 m_public_state.SetValueNoLock(old_state);
6068         }
6069 
6070         // Restore the thread state if we are going to discard the plan execution.  There are three cases where this
6071         // could happen:
6072         // 1) The execution successfully completed
6073         // 2) We hit a breakpoint, and ignore_breakpoints was true
6074         // 3) We got some other error, and discard_on_error was true
6075         bool should_unwind = (return_value == eExpressionInterrupted && options.DoesUnwindOnError())
6076                              || (return_value == eExpressionHitBreakpoint && options.DoesIgnoreBreakpoints());
6077 
6078         if (return_value == eExpressionCompleted
6079             || should_unwind)
6080         {
6081             thread_plan_sp->RestoreThreadState();
6082         }
6083 
6084         // Now do some processing on the results of the run:
6085         if (return_value == eExpressionInterrupted || return_value == eExpressionHitBreakpoint)
6086         {
6087             if (log)
6088             {
6089                 StreamString s;
6090                 if (event_sp)
6091                     event_sp->Dump (&s);
6092                 else
6093                 {
6094                     log->PutCString ("Process::RunThreadPlan(): Stop event that interrupted us is NULL.");
6095                 }
6096 
6097                 StreamString ts;
6098 
6099                 const char *event_explanation = NULL;
6100 
6101                 do
6102                 {
6103                     if (!event_sp)
6104                     {
6105                         event_explanation = "<no event>";
6106                         break;
6107                     }
6108                     else if (event_sp->GetType() == eBroadcastBitInterrupt)
6109                     {
6110                         event_explanation = "<user interrupt>";
6111                         break;
6112                     }
6113                     else
6114                     {
6115                         const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get());
6116 
6117                         if (!event_data)
6118                         {
6119                             event_explanation = "<no event data>";
6120                             break;
6121                         }
6122 
6123                         Process *process = event_data->GetProcessSP().get();
6124 
6125                         if (!process)
6126                         {
6127                             event_explanation = "<no process>";
6128                             break;
6129                         }
6130 
6131                         ThreadList &thread_list = process->GetThreadList();
6132 
6133                         uint32_t num_threads = thread_list.GetSize();
6134                         uint32_t thread_index;
6135 
6136                         ts.Printf("<%u threads> ", num_threads);
6137 
6138                         for (thread_index = 0;
6139                              thread_index < num_threads;
6140                              ++thread_index)
6141                         {
6142                             Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
6143 
6144                             if (!thread)
6145                             {
6146                                 ts.Printf("<?> ");
6147                                 continue;
6148                             }
6149 
6150                             ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
6151                             RegisterContext *register_context = thread->GetRegisterContext().get();
6152 
6153                             if (register_context)
6154                                 ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
6155                             else
6156                                 ts.Printf("[ip unknown] ");
6157 
6158                             lldb::StopInfoSP stop_info_sp = thread->GetStopInfo();
6159                             if (stop_info_sp)
6160                             {
6161                                 const char *stop_desc = stop_info_sp->GetDescription();
6162                                 if (stop_desc)
6163                                     ts.PutCString (stop_desc);
6164                             }
6165                             ts.Printf(">");
6166                         }
6167 
6168                         event_explanation = ts.GetData();
6169                     }
6170                 } while (0);
6171 
6172                 if (event_explanation)
6173                     log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation);
6174                 else
6175                     log->Printf("Process::RunThreadPlan(): execution interrupted: %s", s.GetData());
6176             }
6177 
6178             if (should_unwind)
6179             {
6180                 if (log)
6181                     log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - discarding thread plans up to %p.",
6182                                  static_cast<void*>(thread_plan_sp.get()));
6183                 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
6184                 thread_plan_sp->SetPrivate (orig_plan_private);
6185             }
6186             else
6187             {
6188                 if (log)
6189                     log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - for plan: %p not discarding.",
6190                                  static_cast<void*>(thread_plan_sp.get()));
6191             }
6192         }
6193         else if (return_value == eExpressionSetupError)
6194         {
6195             if (log)
6196                 log->PutCString("Process::RunThreadPlan(): execution set up error.");
6197 
6198             if (options.DoesUnwindOnError())
6199             {
6200                 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
6201                 thread_plan_sp->SetPrivate (orig_plan_private);
6202             }
6203         }
6204         else
6205         {
6206             if (thread->IsThreadPlanDone (thread_plan_sp.get()))
6207             {
6208                 if (log)
6209                     log->PutCString("Process::RunThreadPlan(): thread plan is done");
6210                 return_value = eExpressionCompleted;
6211             }
6212             else if (thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
6213             {
6214                 if (log)
6215                     log->PutCString("Process::RunThreadPlan(): thread plan was discarded");
6216                 return_value = eExpressionDiscarded;
6217             }
6218             else
6219             {
6220                 if (log)
6221                     log->PutCString("Process::RunThreadPlan(): thread plan stopped in mid course");
6222                 if (options.DoesUnwindOnError() && thread_plan_sp)
6223                 {
6224                     if (log)
6225                         log->PutCString("Process::RunThreadPlan(): discarding thread plan 'cause unwind_on_error is set.");
6226                     thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
6227                     thread_plan_sp->SetPrivate (orig_plan_private);
6228                 }
6229             }
6230         }
6231 
6232         // Thread we ran the function in may have gone away because we ran the target
6233         // Check that it's still there, and if it is put it back in the context.  Also restore the
6234         // frame in the context if it is still present.
6235         thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
6236         if (thread)
6237         {
6238             exe_ctx.SetFrameSP (thread->GetFrameWithStackID (ctx_frame_id));
6239         }
6240 
6241         // Also restore the current process'es selected frame & thread, since this function calling may
6242         // be done behind the user's back.
6243 
6244         if (selected_tid != LLDB_INVALID_THREAD_ID)
6245         {
6246             if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid())
6247             {
6248                 // We were able to restore the selected thread, now restore the frame:
6249                 Mutex::Locker lock(GetThreadList().GetMutex());
6250                 StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
6251                 if (old_frame_sp)
6252                     GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
6253             }
6254         }
6255     }
6256 
6257     // If the process exited during the run of the thread plan, notify everyone.
6258 
6259     if (event_to_broadcast_sp)
6260     {
6261         if (log)
6262             log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
6263         BroadcastEvent(event_to_broadcast_sp);
6264     }
6265 
6266     return return_value;
6267 }
6268 
6269 const char *
6270 Process::ExecutionResultAsCString (ExpressionResults result)
6271 {
6272     const char *result_name;
6273 
6274     switch (result)
6275     {
6276         case eExpressionCompleted:
6277             result_name = "eExpressionCompleted";
6278             break;
6279         case eExpressionDiscarded:
6280             result_name = "eExpressionDiscarded";
6281             break;
6282         case eExpressionInterrupted:
6283             result_name = "eExpressionInterrupted";
6284             break;
6285         case eExpressionHitBreakpoint:
6286             result_name = "eExpressionHitBreakpoint";
6287             break;
6288         case eExpressionSetupError:
6289             result_name = "eExpressionSetupError";
6290             break;
6291         case eExpressionParseError:
6292             result_name = "eExpressionParseError";
6293             break;
6294         case eExpressionResultUnavailable:
6295             result_name = "eExpressionResultUnavailable";
6296             break;
6297         case eExpressionTimedOut:
6298             result_name = "eExpressionTimedOut";
6299             break;
6300         case eExpressionStoppedForDebug:
6301             result_name = "eExpressionStoppedForDebug";
6302             break;
6303     }
6304     return result_name;
6305 }
6306 
6307 void
6308 Process::GetStatus (Stream &strm)
6309 {
6310     const StateType state = GetState();
6311     if (StateIsStoppedState(state, false))
6312     {
6313         if (state == eStateExited)
6314         {
6315             int exit_status = GetExitStatus();
6316             const char *exit_description = GetExitDescription();
6317             strm.Printf ("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
6318                           GetID(),
6319                           exit_status,
6320                           exit_status,
6321                           exit_description ? exit_description : "");
6322         }
6323         else
6324         {
6325             if (state == eStateConnected)
6326                 strm.Printf ("Connected to remote target.\n");
6327             else
6328                 strm.Printf ("Process %" PRIu64 " %s\n", GetID(), StateAsCString (state));
6329         }
6330     }
6331     else
6332     {
6333         strm.Printf ("Process %" PRIu64 " is running.\n", GetID());
6334     }
6335 }
6336 
6337 size_t
6338 Process::GetThreadStatus (Stream &strm,
6339                           bool only_threads_with_stop_reason,
6340                           uint32_t start_frame,
6341                           uint32_t num_frames,
6342                           uint32_t num_frames_with_source)
6343 {
6344     size_t num_thread_infos_dumped = 0;
6345 
6346     // You can't hold the thread list lock while calling Thread::GetStatus.  That very well might run code (e.g. if we need it
6347     // to get return values or arguments.)  For that to work the process has to be able to acquire it.  So instead copy the thread
6348     // ID's, and look them up one by one:
6349 
6350     uint32_t num_threads;
6351     std::vector<lldb::tid_t> thread_id_array;
6352     //Scope for thread list locker;
6353     {
6354         Mutex::Locker locker (GetThreadList().GetMutex());
6355         ThreadList &curr_thread_list = GetThreadList();
6356         num_threads = curr_thread_list.GetSize();
6357         uint32_t idx;
6358         thread_id_array.resize(num_threads);
6359         for (idx = 0; idx < num_threads; ++idx)
6360             thread_id_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetID();
6361     }
6362 
6363     for (uint32_t i = 0; i < num_threads; i++)
6364     {
6365         ThreadSP thread_sp(GetThreadList().FindThreadByID(thread_id_array[i]));
6366         if (thread_sp)
6367         {
6368             if (only_threads_with_stop_reason)
6369             {
6370                 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
6371                 if (stop_info_sp.get() == NULL || !stop_info_sp->IsValid())
6372                     continue;
6373             }
6374             thread_sp->GetStatus (strm,
6375                                start_frame,
6376                                num_frames,
6377                                num_frames_with_source);
6378             ++num_thread_infos_dumped;
6379         }
6380         else
6381         {
6382             Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
6383             if (log)
6384                 log->Printf("Process::GetThreadStatus - thread 0x" PRIu64 " vanished while running Thread::GetStatus.");
6385 
6386         }
6387     }
6388     return num_thread_infos_dumped;
6389 }
6390 
6391 void
6392 Process::AddInvalidMemoryRegion (const LoadRange &region)
6393 {
6394     m_memory_cache.AddInvalidRange(region.GetRangeBase(), region.GetByteSize());
6395 }
6396 
6397 bool
6398 Process::RemoveInvalidMemoryRange (const LoadRange &region)
6399 {
6400     return m_memory_cache.RemoveInvalidRange(region.GetRangeBase(), region.GetByteSize());
6401 }
6402 
6403 void
6404 Process::AddPreResumeAction (PreResumeActionCallback callback, void *baton)
6405 {
6406     m_pre_resume_actions.push_back(PreResumeCallbackAndBaton (callback, baton));
6407 }
6408 
6409 bool
6410 Process::RunPreResumeActions ()
6411 {
6412     bool result = true;
6413     while (!m_pre_resume_actions.empty())
6414     {
6415         struct PreResumeCallbackAndBaton action = m_pre_resume_actions.back();
6416         m_pre_resume_actions.pop_back();
6417         bool this_result = action.callback (action.baton);
6418         if (result == true)
6419             result = this_result;
6420     }
6421     return result;
6422 }
6423 
6424 void
6425 Process::ClearPreResumeActions ()
6426 {
6427     m_pre_resume_actions.clear();
6428 }
6429 
6430 ProcessRunLock &
6431 Process::GetRunLock()
6432 {
6433     if (m_private_state_thread.EqualsThread(Host::GetCurrentThread()))
6434         return m_private_run_lock;
6435     else
6436         return m_public_run_lock;
6437 }
6438 
6439 void
6440 Process::Flush ()
6441 {
6442     m_thread_list.Flush();
6443     m_extended_thread_list.Flush();
6444     m_extended_thread_stop_id =  0;
6445     m_queue_list.Clear();
6446     m_queue_list_stop_id = 0;
6447 }
6448 
6449 void
6450 Process::DidExec ()
6451 {
6452     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
6453     if (log)
6454         log->Printf ("Process::%s()", __FUNCTION__);
6455 
6456     Target &target = GetTarget();
6457     target.CleanupProcess ();
6458     target.ClearModules(false);
6459     m_dynamic_checkers_ap.reset();
6460     m_abi_sp.reset();
6461     m_system_runtime_ap.reset();
6462     m_os_ap.reset();
6463     m_dyld_ap.reset();
6464     m_jit_loaders_ap.reset();
6465     m_image_tokens.clear();
6466     m_allocated_memory_cache.Clear();
6467     m_language_runtimes.clear();
6468     m_instrumentation_runtimes.clear();
6469     m_thread_list.DiscardThreadPlans();
6470     m_memory_cache.Clear(true);
6471     m_stop_info_override_callback = NULL;
6472     DoDidExec();
6473     CompleteAttach ();
6474     // Flush the process (threads and all stack frames) after running CompleteAttach()
6475     // in case the dynamic loader loaded things in new locations.
6476     Flush();
6477 
6478     // After we figure out what was loaded/unloaded in CompleteAttach,
6479     // we need to let the target know so it can do any cleanup it needs to.
6480     target.DidExec();
6481 }
6482 
6483 addr_t
6484 Process::ResolveIndirectFunction(const Address *address, Error &error)
6485 {
6486     if (address == nullptr)
6487     {
6488         error.SetErrorString("Invalid address argument");
6489         return LLDB_INVALID_ADDRESS;
6490     }
6491 
6492     addr_t function_addr = LLDB_INVALID_ADDRESS;
6493 
6494     addr_t addr = address->GetLoadAddress(&GetTarget());
6495     std::map<addr_t,addr_t>::const_iterator iter = m_resolved_indirect_addresses.find(addr);
6496     if (iter != m_resolved_indirect_addresses.end())
6497     {
6498         function_addr = (*iter).second;
6499     }
6500     else
6501     {
6502         if (!InferiorCall(this, address, function_addr))
6503         {
6504             Symbol *symbol = address->CalculateSymbolContextSymbol();
6505             error.SetErrorStringWithFormat ("Unable to call resolver for indirect function %s",
6506                                           symbol ? symbol->GetName().AsCString() : "<UNKNOWN>");
6507             function_addr = LLDB_INVALID_ADDRESS;
6508         }
6509         else
6510         {
6511             m_resolved_indirect_addresses.insert(std::pair<addr_t, addr_t>(addr, function_addr));
6512         }
6513     }
6514     return function_addr;
6515 }
6516 
6517 void
6518 Process::ModulesDidLoad (ModuleList &module_list)
6519 {
6520     SystemRuntime *sys_runtime = GetSystemRuntime();
6521     if (sys_runtime)
6522     {
6523         sys_runtime->ModulesDidLoad (module_list);
6524     }
6525 
6526     GetJITLoaders().ModulesDidLoad (module_list);
6527 
6528     // Give runtimes a chance to be created.
6529     InstrumentationRuntime::ModulesDidLoad(module_list, this, m_instrumentation_runtimes);
6530 
6531     // Tell runtimes about new modules.
6532     for (auto pos = m_instrumentation_runtimes.begin(); pos != m_instrumentation_runtimes.end(); ++pos)
6533     {
6534         InstrumentationRuntimeSP runtime = pos->second;
6535         runtime->ModulesDidLoad(module_list);
6536     }
6537 
6538     // Let any language runtimes we have already created know
6539     // about the modules that loaded.
6540 
6541     // Iterate over a copy of this language runtime list in case
6542     // the language runtime ModulesDidLoad somehow causes the language
6543     // riuntime to be unloaded.
6544     LanguageRuntimeCollection language_runtimes(m_language_runtimes);
6545     for (const auto &pair: language_runtimes)
6546     {
6547         // We must check language_runtime_sp to make sure it is not
6548         // NULL as we might cache the fact that we didn't have a
6549         // language runtime for a language.
6550         LanguageRuntimeSP language_runtime_sp = pair.second;
6551         if (language_runtime_sp)
6552             language_runtime_sp->ModulesDidLoad(module_list);
6553     }
6554 }
6555 
6556 void
6557 Process::PrintWarning (uint64_t warning_type, void *repeat_key, const char *fmt, ...)
6558 {
6559     bool print_warning = true;
6560 
6561     StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
6562     if (stream_sp.get() == nullptr)
6563         return;
6564     if (warning_type == eWarningsOptimization
6565         && GetWarningsOptimization() == false)
6566     {
6567         return;
6568     }
6569 
6570     if (repeat_key != nullptr)
6571     {
6572         WarningsCollection::iterator it = m_warnings_issued.find (warning_type);
6573         if (it == m_warnings_issued.end())
6574         {
6575             m_warnings_issued[warning_type] = WarningsPointerSet();
6576             m_warnings_issued[warning_type].insert (repeat_key);
6577         }
6578         else
6579         {
6580             if (it->second.find (repeat_key) != it->second.end())
6581             {
6582                 print_warning = false;
6583             }
6584             else
6585             {
6586                 it->second.insert (repeat_key);
6587             }
6588         }
6589     }
6590 
6591     if (print_warning)
6592     {
6593         va_list args;
6594         va_start (args, fmt);
6595         stream_sp->PrintfVarArg (fmt, args);
6596         va_end (args);
6597     }
6598 }
6599 
6600 void
6601 Process::PrintWarningOptimization (const SymbolContext &sc)
6602 {
6603     if (GetWarningsOptimization() == true
6604         && sc.module_sp.get()
6605         && sc.module_sp->GetFileSpec().GetFilename().IsEmpty() == false
6606         && sc.function
6607         && sc.function->GetIsOptimized() == true)
6608     {
6609         PrintWarning (Process::Warnings::eWarningsOptimization, sc.module_sp.get(), "%s was compiled with optimization - stepping may behave oddly; variables may not be available.\n", sc.module_sp->GetFileSpec().GetFilename().GetCString());
6610     }
6611 }
6612 
6613 ThreadCollectionSP
6614 Process::GetHistoryThreads(lldb::addr_t addr)
6615 {
6616     ThreadCollectionSP threads;
6617 
6618     const MemoryHistorySP &memory_history = MemoryHistory::FindPlugin(shared_from_this());
6619 
6620     if (! memory_history.get()) {
6621         return threads;
6622     }
6623 
6624     threads.reset(new ThreadCollection(memory_history->GetHistoryThreads(addr)));
6625 
6626     return threads;
6627 }
6628 
6629 InstrumentationRuntimeSP
6630 Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type)
6631 {
6632     InstrumentationRuntimeCollection::iterator pos;
6633     pos = m_instrumentation_runtimes.find (type);
6634     if (pos == m_instrumentation_runtimes.end())
6635     {
6636         return InstrumentationRuntimeSP();
6637     }
6638     else
6639         return (*pos).second;
6640 }
6641 
6642 bool
6643 Process::GetModuleSpec(const FileSpec& module_file_spec,
6644                        const ArchSpec& arch,
6645                        ModuleSpec& module_spec)
6646 {
6647     module_spec.Clear();
6648     return false;
6649 }
6650