source/Target/Process.cpp

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