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