diff options
Diffstat (limited to 'source/Target/Process.cpp')
| -rw-r--r-- | source/Target/Process.cpp | 951 |
1 files changed, 504 insertions, 447 deletions
diff --git a/source/Target/Process.cpp b/source/Target/Process.cpp index e4fe419660e2..3d1065450e81 100644 --- a/source/Target/Process.cpp +++ b/source/Target/Process.cpp @@ -9,21 +9,25 @@ // C Includes // C++ Includes +#include <atomic> +#include <mutex> + // Other libraries and framework includes // Project includes -#include "lldb/Target/Process.h" -#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "Plugins/Process/Utility/InferiorCallPOSIX.h" #include "lldb/Breakpoint/BreakpointLocation.h" -#include "lldb/Core/Event.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Core/Debugger.h" +#include "lldb/Core/Event.h" #include "lldb/Core/Log.h" #include "lldb/Core/Module.h" #include "lldb/Core/ModuleSpec.h" #include "lldb/Core/PluginManager.h" #include "lldb/Core/State.h" #include "lldb/Core/StreamFile.h" -#include "lldb/Expression/UserExpression.h" +#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/IRDynamicChecks.h" +#include "lldb/Expression/UserExpression.h" #include "lldb/Host/ConnectionFileDescriptor.h" #include "lldb/Host/FileSystem.h" #include "lldb/Host/Host.h" @@ -36,17 +40,18 @@ #include "lldb/Symbol/Function.h" #include "lldb/Symbol/Symbol.h" #include "lldb/Target/ABI.h" +#include "lldb/Target/CPPLanguageRuntime.h" #include "lldb/Target/DynamicLoader.h" #include "lldb/Target/InstrumentationRuntime.h" #include "lldb/Target/JITLoader.h" #include "lldb/Target/JITLoaderList.h" +#include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/MemoryHistory.h" #include "lldb/Target/MemoryRegionInfo.h" -#include "lldb/Target/OperatingSystem.h" -#include "lldb/Target/LanguageRuntime.h" -#include "lldb/Target/CPPLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h" +#include "lldb/Target/OperatingSystem.h" #include "lldb/Target/Platform.h" +#include "lldb/Target/Process.h" #include "lldb/Target/RegisterContext.h" #include "lldb/Target/StopInfo.h" #include "lldb/Target/SystemRuntime.h" @@ -57,7 +62,6 @@ #include "lldb/Target/ThreadPlanBase.h" #include "lldb/Target/UnixSignals.h" #include "lldb/Utility/NameMatches.h" -#include "Plugins/Process/Utility/InferiorCallPOSIX.h" using namespace lldb; using namespace lldb_private; @@ -111,17 +115,17 @@ public: static PropertyDefinition g_properties[] = { - { "disable-memory-cache" , OptionValue::eTypeBoolean, false, DISABLE_MEM_CACHE_DEFAULT, NULL, NULL, "Disable reading and caching of memory in fixed-size units." }, - { "extra-startup-command", OptionValue::eTypeArray , false, OptionValue::eTypeString, NULL, NULL, "A list containing extra commands understood by the particular process plugin used. " + { "disable-memory-cache" , OptionValue::eTypeBoolean, false, DISABLE_MEM_CACHE_DEFAULT, nullptr, nullptr, "Disable reading and caching of memory in fixed-size units." }, + { "extra-startup-command", OptionValue::eTypeArray , false, OptionValue::eTypeString, nullptr, nullptr, "A list containing extra commands understood by the particular process plugin used. " "For instance, to turn on debugserver logging set this to \"QSetLogging:bitmask=LOG_DEFAULT;\"" }, - { "ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, breakpoints will be ignored during expression evaluation." }, - { "unwind-on-error-in-expressions", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, errors in expression evaluation will unwind the stack back to the state before the call." }, - { "python-os-plugin-path", OptionValue::eTypeFileSpec, false, true, NULL, NULL, "A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class." }, - { "stop-on-sharedlibrary-events" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, stop when a shared library is loaded or unloaded." }, - { "detach-keeps-stopped" , OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, detach will attempt to keep the process stopped." }, - { "memory-cache-line-size" , OptionValue::eTypeUInt64, false, 512, NULL, NULL, "The memory cache line size" }, - { "optimization-warnings" , OptionValue::eTypeBoolean, false, true, NULL, NULL, "If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected." }, - { NULL , OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL } + { "ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, breakpoints will be ignored during expression evaluation." }, + { "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." }, + { "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." }, + { "stop-on-sharedlibrary-events" , OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, stop when a shared library is loaded or unloaded." }, + { "detach-keeps-stopped" , OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, detach will attempt to keep the process stopped." }, + { "memory-cache-line-size" , OptionValue::eTypeUInt64, false, 512, nullptr, nullptr, "The memory cache line size" }, + { "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." }, + { nullptr , OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr } }; enum { @@ -137,10 +141,10 @@ enum { }; ProcessProperties::ProcessProperties (lldb_private::Process *process) : - Properties (), - m_process (process) // Can be NULL for global ProcessProperties + Properties(), + m_process(process) // Can be nullptr for global ProcessProperties { - if (process == NULL) + if (process == nullptr) { // Global process properties, set them up one time m_collection_sp.reset (new ProcessOptionValueProperties(ConstString("process"))); @@ -171,14 +175,14 @@ bool ProcessProperties::GetDisableMemoryCache() const { const uint32_t idx = ePropertyDisableMemCache; - return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); + return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); } uint64_t ProcessProperties::GetMemoryCacheLineSize() const { const uint32_t idx = ePropertyMemCacheLineSize; - return m_collection_sp->GetPropertyAtIndexAsUInt64 (NULL, idx, g_properties[idx].default_uint_value); + return m_collection_sp->GetPropertyAtIndexAsUInt64(nullptr, idx, g_properties[idx].default_uint_value); } Args @@ -186,7 +190,7 @@ ProcessProperties::GetExtraStartupCommands () const { Args args; const uint32_t idx = ePropertyExtraStartCommand; - m_collection_sp->GetPropertyAtIndexAsArgs(NULL, idx, args); + m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args); return args; } @@ -194,84 +198,84 @@ void ProcessProperties::SetExtraStartupCommands (const Args &args) { const uint32_t idx = ePropertyExtraStartCommand; - m_collection_sp->SetPropertyAtIndexFromArgs(NULL, idx, args); + m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args); } FileSpec ProcessProperties::GetPythonOSPluginPath () const { const uint32_t idx = ePropertyPythonOSPluginPath; - return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx); + return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx); } void ProcessProperties::SetPythonOSPluginPath (const FileSpec &file) { const uint32_t idx = ePropertyPythonOSPluginPath; - m_collection_sp->SetPropertyAtIndexAsFileSpec(NULL, idx, file); + m_collection_sp->SetPropertyAtIndexAsFileSpec(nullptr, idx, file); } bool ProcessProperties::GetIgnoreBreakpointsInExpressions () const { const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions; - return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0); + return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); } void ProcessProperties::SetIgnoreBreakpointsInExpressions (bool ignore) { const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions; - m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore); + m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore); } bool ProcessProperties::GetUnwindOnErrorInExpressions () const { const uint32_t idx = ePropertyUnwindOnErrorInExpressions; - return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0); + return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); } void ProcessProperties::SetUnwindOnErrorInExpressions (bool ignore) { const uint32_t idx = ePropertyUnwindOnErrorInExpressions; - m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, ignore); + m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore); } bool ProcessProperties::GetStopOnSharedLibraryEvents () const { const uint32_t idx = ePropertyStopOnSharedLibraryEvents; - return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0); + return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); } void ProcessProperties::SetStopOnSharedLibraryEvents (bool stop) { const uint32_t idx = ePropertyStopOnSharedLibraryEvents; - m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop); + m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop); } bool ProcessProperties::GetDetachKeepsStopped () const { const uint32_t idx = ePropertyDetachKeepsStopped; - return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value != 0); + return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); } void ProcessProperties::SetDetachKeepsStopped (bool stop) { const uint32_t idx = ePropertyDetachKeepsStopped; - m_collection_sp->SetPropertyAtIndexAsBoolean(NULL, idx, stop); + m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop); } bool ProcessProperties::GetWarningsOptimization () const { const uint32_t idx = ePropertyWarningOptimization; - return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); + return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0); } void @@ -294,7 +298,7 @@ ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const const uint32_t argc = m_arguments.GetArgumentCount(); if (argc > 0) { - for (uint32_t i=0; i<argc; i++) + for (uint32_t i = 0; i < argc; i++) { const char *arg = m_arguments.GetArgumentAtIndex(i); if (i < 10) @@ -307,7 +311,7 @@ ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const const uint32_t envc = m_environment.GetArgumentCount(); if (envc > 0) { - for (uint32_t i=0; i<envc; i++) + for (uint32_t i = 0; i < envc; i++) { const char *env = m_environment.GetArgumentAtIndex(i); if (i < 10) @@ -419,7 +423,7 @@ ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_ar const uint32_t argc = m_arguments.GetArgumentCount(); if (argc > 0) { - for (uint32_t i=0; i<argc; i++) + for (uint32_t i = 0; i < argc; i++) { if (i > 0) s.PutChar (' '); @@ -545,29 +549,29 @@ ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *op OptionDefinition ProcessLaunchCommandOptions::g_option_table[] = { -{ LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Stop at the entry point of the program when launching a process."}, -{ LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean, "Set whether to disable address space layout randomization when launching a process."}, -{ LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."}, -{ LLDB_OPT_SET_ALL, false, "working-dir", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeDirectoryName, "Set the current working directory to <path> when running the inferior."}, -{ LLDB_OPT_SET_ALL, false, "arch", 'a', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous."}, -{ LLDB_OPT_SET_ALL, false, "environment", 'v', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeNone, "Specify an environment variable name/value string (--environment NAME=VALUE). Can be specified multiple times for subsequent environment entries."}, -{ LLDB_OPT_SET_1|LLDB_OPT_SET_2|LLDB_OPT_SET_3, false, "shell", 'c', OptionParser::eOptionalArgument, NULL, NULL, 0, eArgTypeFilename, "Run the process in a shell (not supported on all platforms)."}, +{ 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." }, +{ 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." }, +{ LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin, "Name of the process plugin you want to use." }, +{ 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." }, +{ LLDB_OPT_SET_ALL, false, "arch", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous." }, +{ 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." }, +{ 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)." }, -{ LLDB_OPT_SET_1 , false, "stdin", 'i', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename, "Redirect stdin for the process to <filename>."}, -{ LLDB_OPT_SET_1 , false, "stdout", 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename, "Redirect stdout for the process to <filename>."}, -{ LLDB_OPT_SET_1 , false, "stderr", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeFilename, "Redirect stderr for the process to <filename>."}, +{ LLDB_OPT_SET_1 , false, "stdin", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Redirect stdin for the process to <filename>." }, +{ LLDB_OPT_SET_1 , false, "stdout", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Redirect stdout for the process to <filename>." }, +{ LLDB_OPT_SET_1 , false, "stderr", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Redirect stderr for the process to <filename>." }, -{ LLDB_OPT_SET_2 , false, "tty", 't', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)."}, +{ LLDB_OPT_SET_2 , false, "tty", 't', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)." }, -{ LLDB_OPT_SET_3 , false, "no-stdio", 'n', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Do not set up for terminal I/O to go to running process."}, -{ LLDB_OPT_SET_4, false, "shell-expand-args", 'X', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean, "Set whether to shell expand arguments to the process when launching."}, -{ 0 , false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } +{ 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." }, +{ 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." }, +{ 0 , false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr } }; bool ProcessInstanceInfoMatch::NameMatches (const char *process_name) const { - if (m_name_match_type == eNameMatchIgnore || process_name == NULL) + if (m_name_match_type == eNameMatchIgnore || process_name == nullptr) return true; const char *match_name = m_match_info.GetName(); if (!match_name) @@ -654,19 +658,19 @@ ProcessInstanceInfoMatch::Clear() } ProcessSP -Process::FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, Listener &listener, const FileSpec *crash_file_path) +Process::FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, ListenerSP listener_sp, const FileSpec *crash_file_path) { static uint32_t g_process_unique_id = 0; ProcessSP process_sp; - ProcessCreateInstance create_callback = NULL; + ProcessCreateInstance create_callback = nullptr; if (plugin_name) { ConstString const_plugin_name(plugin_name); create_callback = PluginManager::GetProcessCreateCallbackForPluginName (const_plugin_name); if (create_callback) { - process_sp = create_callback(target_sp, listener, crash_file_path); + process_sp = create_callback(target_sp, listener_sp, crash_file_path); if (process_sp) { if (process_sp->CanDebug(target_sp, true)) @@ -680,9 +684,9 @@ Process::FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, Listener } else { - for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != NULL; ++idx) + for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != nullptr; ++idx) { - process_sp = create_callback(target_sp, listener, crash_file_path); + process_sp = create_callback(target_sp, listener_sp, crash_file_path); if (process_sp) { if (process_sp->CanDebug(target_sp, false)) @@ -705,113 +709,107 @@ Process::GetStaticBroadcasterClass () return class_name; } -Process::Process(lldb::TargetSP target_sp, Listener &listener) : - Process(target_sp, listener, UnixSignals::Create(HostInfo::GetArchitecture())) +Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp) : + Process(target_sp, listener_sp, UnixSignals::Create(HostInfo::GetArchitecture())) { // This constructor just delegates to the full Process constructor, // defaulting to using the Host's UnixSignals. } -Process::Process(lldb::TargetSP target_sp, Listener &listener, const UnixSignalsSP &unix_signals_sp) : - ProcessProperties (this), - UserID (LLDB_INVALID_PROCESS_ID), - Broadcaster (&(target_sp->GetDebugger()), Process::GetStaticBroadcasterClass().AsCString()), - m_target_sp (target_sp), - m_public_state (eStateUnloaded), - m_private_state (eStateUnloaded), - m_private_state_broadcaster (NULL, "lldb.process.internal_state_broadcaster"), - m_private_state_control_broadcaster (NULL, "lldb.process.internal_state_control_broadcaster"), - m_private_state_listener ("lldb.process.internal_state_listener"), - m_private_state_control_wait(), - m_mod_id (), - m_process_unique_id(0), - m_thread_index_id (0), - m_thread_id_to_index_id_map (), - m_exit_status (-1), - m_exit_string (), - m_exit_status_mutex(), - m_thread_mutex (Mutex::eMutexTypeRecursive), - m_thread_list_real (this), - m_thread_list (this), - m_extended_thread_list (this), - m_extended_thread_stop_id (0), - m_queue_list (this), - m_queue_list_stop_id (0), - m_notifications (), - m_image_tokens (), - m_listener (listener), - m_breakpoint_site_list (), - m_dynamic_checkers_ap (), - m_unix_signals_sp (unix_signals_sp), - m_abi_sp (), - m_process_input_reader (), - m_stdio_communication ("process.stdio"), - m_stdio_communication_mutex (Mutex::eMutexTypeRecursive), - m_stdin_forward (false), - m_stdout_data (), - m_stderr_data (), - m_profile_data_comm_mutex (Mutex::eMutexTypeRecursive), - m_profile_data (), - m_iohandler_sync (0), - m_memory_cache (*this), - m_allocated_memory_cache (*this), - m_should_detach (false), - m_next_event_action_ap(), - m_public_run_lock (), - m_private_run_lock (), - m_stop_info_override_callback (NULL), - m_finalizing (false), - m_finalize_called (false), - m_clear_thread_plans_on_stop (false), - m_force_next_event_delivery (false), - m_last_broadcast_state (eStateInvalid), - m_destroy_in_process (false), - m_can_interpret_function_calls(false), - m_warnings_issued (), - m_can_jit(eCanJITDontKnow) -{ - CheckInWithManager (); - - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); +Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp, const UnixSignalsSP &unix_signals_sp) + : ProcessProperties(this), + UserID(LLDB_INVALID_PROCESS_ID), + Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()), Process::GetStaticBroadcasterClass().AsCString()), + m_target_sp(target_sp), + m_public_state(eStateUnloaded), + m_private_state(eStateUnloaded), + m_private_state_broadcaster(nullptr, "lldb.process.internal_state_broadcaster"), + m_private_state_control_broadcaster(nullptr, "lldb.process.internal_state_control_broadcaster"), + m_private_state_listener_sp(Listener::MakeListener("lldb.process.internal_state_listener")), + m_mod_id(), + m_process_unique_id(0), + m_thread_index_id(0), + m_thread_id_to_index_id_map(), + m_exit_status(-1), + m_exit_string(), + m_exit_status_mutex(), + m_thread_mutex(), + m_thread_list_real(this), + m_thread_list(this), + m_extended_thread_list(this), + m_extended_thread_stop_id(0), + m_queue_list(this), + m_queue_list_stop_id(0), + m_notifications(), + m_image_tokens(), + m_listener_sp(listener_sp), + m_breakpoint_site_list(), + m_dynamic_checkers_ap(), + m_unix_signals_sp(unix_signals_sp), + m_abi_sp(), + m_process_input_reader(), + m_stdio_communication("process.stdio"), + m_stdio_communication_mutex(), + m_stdin_forward(false), + m_stdout_data(), + m_stderr_data(), + m_profile_data_comm_mutex(), + m_profile_data(), + m_iohandler_sync(0), + m_memory_cache(*this), + m_allocated_memory_cache(*this), + m_should_detach(false), + m_next_event_action_ap(), + m_public_run_lock(), + m_private_run_lock(), + m_stop_info_override_callback(nullptr), + m_finalizing(false), + m_finalize_called(false), + m_clear_thread_plans_on_stop(false), + m_force_next_event_delivery(false), + m_last_broadcast_state(eStateInvalid), + m_destroy_in_process(false), + m_can_interpret_function_calls(false), + m_warnings_issued(), + m_run_thread_plan_lock(), + m_can_jit(eCanJITDontKnow) +{ + CheckInWithManager(); + + Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); if (log) - log->Printf ("%p Process::Process()", static_cast<void*>(this)); + log->Printf("%p Process::Process()", static_cast<void *>(this)); if (!m_unix_signals_sp) m_unix_signals_sp = std::make_shared<UnixSignals>(); - SetEventName (eBroadcastBitStateChanged, "state-changed"); - SetEventName (eBroadcastBitInterrupt, "interrupt"); - SetEventName (eBroadcastBitSTDOUT, "stdout-available"); - SetEventName (eBroadcastBitSTDERR, "stderr-available"); - SetEventName (eBroadcastBitProfileData, "profile-data-available"); - - m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlStop , "control-stop" ); - m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlPause , "control-pause" ); - m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlResume, "control-resume"); - - listener.StartListeningForEvents (this, - eBroadcastBitStateChanged | - eBroadcastBitInterrupt | - eBroadcastBitSTDOUT | - eBroadcastBitSTDERR | - eBroadcastBitProfileData); - - m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster, - eBroadcastBitStateChanged | - eBroadcastBitInterrupt); - - m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster, - eBroadcastInternalStateControlStop | - eBroadcastInternalStateControlPause | - eBroadcastInternalStateControlResume); + SetEventName(eBroadcastBitStateChanged, "state-changed"); + SetEventName(eBroadcastBitInterrupt, "interrupt"); + SetEventName(eBroadcastBitSTDOUT, "stdout-available"); + SetEventName(eBroadcastBitSTDERR, "stderr-available"); + SetEventName(eBroadcastBitProfileData, "profile-data-available"); + + m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlStop, "control-stop"); + m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlPause, "control-pause"); + m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlResume, "control-resume"); + + m_listener_sp->StartListeningForEvents(this, eBroadcastBitStateChanged | eBroadcastBitInterrupt | + eBroadcastBitSTDOUT | eBroadcastBitSTDERR | + eBroadcastBitProfileData); + + m_private_state_listener_sp->StartListeningForEvents(&m_private_state_broadcaster, + eBroadcastBitStateChanged | eBroadcastBitInterrupt); + + m_private_state_listener_sp->StartListeningForEvents( + &m_private_state_control_broadcaster, eBroadcastInternalStateControlStop | eBroadcastInternalStateControlPause | + eBroadcastInternalStateControlResume); // We need something valid here, even if just the default UnixSignalsSP. - assert (m_unix_signals_sp && "null m_unix_signals_sp after initialization"); + assert(m_unix_signals_sp && "null m_unix_signals_sp after initialization"); // Allow the platform to override the default cache line size - OptionValueSP value_sp = - m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)->GetValue(); + OptionValueSP value_sp = m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)->GetValue(); uint32_t platform_cache_line_size = target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize(); - if (! value_sp->OptionWasSet() && platform_cache_line_size != 0) + if (!value_sp->OptionWasSet() && platform_cache_line_size != 0) value_sp->SetUInt64Value(platform_cache_line_size); } @@ -831,10 +829,14 @@ Process::~Process() const ProcessPropertiesSP & Process::GetGlobalProperties() { - static ProcessPropertiesSP g_settings_sp; - if (!g_settings_sp) - g_settings_sp.reset (new ProcessProperties (NULL)); - return g_settings_sp; + // NOTE: intentional leak so we don't crash if global destructor chain gets + // called as other threads still use the result of this function + static ProcessPropertiesSP *g_settings_sp_ptr = nullptr; + static std::once_flag g_once_flag; + std::call_once(g_once_flag, []() { + g_settings_sp_ptr = new ProcessPropertiesSP(new ProcessProperties(nullptr)); + }); + return *g_settings_sp_ptr; } void @@ -890,14 +892,14 @@ Process::Finalize() m_language_runtimes.clear(); m_instrumentation_runtimes.clear(); m_next_event_action_ap.reset(); - m_stop_info_override_callback = NULL; + m_stop_info_override_callback = nullptr; // Clear the last natural stop ID since it has a strong // reference to this process m_mod_id.SetStopEventForLastNaturalStopID(EventSP()); //#ifdef LLDB_CONFIGURATION_DEBUG // StreamFile s(stdout, false); // EventSP event_sp; -// while (m_private_state_listener.GetNextEvent(event_sp)) +// while (m_private_state_listener_sp->GetNextEvent(event_sp)) // { // event_sp->Dump (&s); // s.EOL(); @@ -906,7 +908,7 @@ Process::Finalize() // We have to be very careful here as the m_private_state_listener might // contain events that have ProcessSP values in them which can keep this // process around forever. These events need to be cleared out. - m_private_state_listener.Clear(); + m_private_state_listener_sp->Clear(); m_public_run_lock.TrySetRunning(); // This will do nothing if already locked m_public_run_lock.SetStopped(); m_private_run_lock.TrySetRunning(); // This will do nothing if already locked @@ -918,7 +920,7 @@ void Process::RegisterNotificationCallbacks (const Notifications& callbacks) { m_notifications.push_back(callbacks); - if (callbacks.initialize != NULL) + if (callbacks.initialize != nullptr) callbacks.initialize (callbacks.baton, this); } @@ -963,7 +965,7 @@ Process::GetNextEvent (EventSP &event_sp) { StateType state = eStateInvalid; - if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp) + if (m_listener_sp->GetNextEventForBroadcaster (this, event_sp) && event_sp) state = Process::ProcessEventData::GetStateFromEvent (event_sp.get()); return state; @@ -973,7 +975,7 @@ void Process::SyncIOHandler (uint32_t iohandler_id, uint64_t timeout_msec) { // don't sync (potentially context switch) in case where there is no process IO - if (! m_process_input_reader) + if (!m_process_input_reader) return; TimeValue timeout = TimeValue::Now(); @@ -990,7 +992,7 @@ StateType Process::WaitForProcessToStop (const TimeValue *timeout, EventSP *event_sp_ptr, bool wait_always, - Listener *hijack_listener, + ListenerSP hijack_listener_sp, Stream *stream, bool use_run_lock) { @@ -1019,7 +1021,7 @@ Process::WaitForProcessToStop (const TimeValue *timeout, __FUNCTION__); // We need to toggle the run lock as this won't get done in // SetPublicState() if the process is hijacked. - if (hijack_listener && use_run_lock) + if (hijack_listener_sp && use_run_lock) m_public_run_lock.SetStopped(); return state; } @@ -1027,11 +1029,11 @@ Process::WaitForProcessToStop (const TimeValue *timeout, while (state != eStateInvalid) { EventSP event_sp; - state = WaitForStateChangedEvents (timeout, event_sp, hijack_listener); + state = WaitForStateChangedEvents (timeout, event_sp, hijack_listener_sp); if (event_sp_ptr && event_sp) *event_sp_ptr = event_sp; - bool pop_process_io_handler = hijack_listener != NULL; + bool pop_process_io_handler = (hijack_listener_sp.get() != nullptr); Process::HandleProcessStateChangedEvent (event_sp, stream, pop_process_io_handler); switch (state) @@ -1042,7 +1044,7 @@ Process::WaitForProcessToStop (const TimeValue *timeout, case eStateUnloaded: // We need to toggle the run lock as this won't get done in // SetPublicState() if the process is hijacked. - if (hijack_listener && use_run_lock) + if (hijack_listener_sp && use_run_lock) m_public_run_lock.SetStopped(); return state; case eStateStopped: @@ -1052,7 +1054,7 @@ Process::WaitForProcessToStop (const TimeValue *timeout, { // We need to toggle the run lock as this won't get done in // SetPublicState() if the process is hijacked. - if (hijack_listener && use_run_lock) + if (hijack_listener_sp && use_run_lock) m_public_run_lock.SetStopped(); return state; } @@ -1068,7 +1070,7 @@ Process::HandleProcessStateChangedEvent (const EventSP &event_sp, Stream *stream, bool &pop_process_io_handler) { - const bool handle_pop = pop_process_io_handler == true; + const bool handle_pop = pop_process_io_handler; pop_process_io_handler = false; ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get()); @@ -1088,15 +1090,12 @@ Process::HandleProcessStateChangedEvent (const EventSP &event_sp, case eStateLaunching: case eStateStepping: case eStateDetached: - { - if (stream) - stream->Printf ("Process %" PRIu64 " %s\n", - process_sp->GetID(), - StateAsCString (event_state)); - - if (event_state == eStateDetached) - pop_process_io_handler = true; - } + if (stream) + stream->Printf("Process %" PRIu64 " %s\n", + process_sp->GetID(), + StateAsCString (event_state)); + if (event_state == eStateDetached) + pop_process_io_handler = true; break; case eStateConnected: @@ -1149,7 +1148,7 @@ Process::HandleProcessStateChangedEvent (const EventSP &event_sp, // Lock the thread list so it doesn't change on us, this is the scope for the locker: { ThreadList &thread_list = process_sp->GetThreadList(); - Mutex::Locker locker (thread_list.GetMutex()); + std::lock_guard<std::recursive_mutex> guard(thread_list.GetMutex()); ThreadSP curr_thread (thread_list.GetSelectedThread()); ThreadSP thread; @@ -1271,7 +1270,6 @@ Process::WaitForState(const TimeValue *timeout, const uint32_t num_match_states) { EventSP event_sp; - uint32_t i; StateType state = GetState(); while (state != eStateInvalid) { @@ -1280,9 +1278,9 @@ Process::WaitForState(const TimeValue *timeout, if (state == eStateDetached || state == eStateExited) return state; - state = WaitForStateChangedEvents (timeout, event_sp, NULL); + state = WaitForStateChangedEvents(timeout, event_sp, nullptr); - for (i=0; i<num_match_states; ++i) + for (uint32_t i = 0; i < num_match_states; ++i) { if (match_states[i] == state) return state; @@ -1292,11 +1290,11 @@ Process::WaitForState(const TimeValue *timeout, } bool -Process::HijackProcessEvents (Listener *listener) +Process::HijackProcessEvents (ListenerSP listener_sp) { - if (listener != NULL) + if (listener_sp) { - return HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt); + return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged | eBroadcastBitInterrupt); } else return false; @@ -1309,7 +1307,7 @@ Process::RestoreProcessEvents () } StateType -Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp, Listener *hijack_listener) +Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp, ListenerSP hijack_listener_sp) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); @@ -1317,15 +1315,15 @@ Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp, log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__, static_cast<const void*>(timeout)); - Listener *listener = hijack_listener; - if (listener == NULL) - listener = &m_listener; + ListenerSP listener_sp = hijack_listener_sp; + if (!listener_sp) + listener_sp = m_listener_sp; StateType state = eStateInvalid; - if (listener->WaitForEventForBroadcasterWithType (timeout, - this, - eBroadcastBitStateChanged | eBroadcastBitInterrupt, - event_sp)) + if (listener_sp->WaitForEventForBroadcasterWithType (timeout, + this, + eBroadcastBitStateChanged | eBroadcastBitInterrupt, + event_sp)) { if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged) state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); @@ -1349,7 +1347,7 @@ Process::PeekAtStateChangedEvents () log->Printf ("Process::%s...", __FUNCTION__); Event *event_ptr; - event_ptr = m_listener.PeekAtNextEventForBroadcasterWithType (this, + event_ptr = m_listener_sp->PeekAtNextEventForBroadcasterWithType (this, eBroadcastBitStateChanged); if (log) { @@ -1378,7 +1376,7 @@ Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &ev static_cast<const void*>(timeout)); StateType state = eStateInvalid; - if (m_private_state_listener.WaitForEventForBroadcasterWithType (timeout, + if (m_private_state_listener_sp->WaitForEventForBroadcasterWithType (timeout, &m_private_state_broadcaster, eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp)) @@ -1405,9 +1403,9 @@ Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool static_cast<const void*>(timeout)); if (control_only) - return m_private_state_listener.WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp); + return m_private_state_listener_sp->WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp); else - return m_private_state_listener.WaitForEvent(timeout, event_sp); + return m_private_state_listener_sp->WaitForEvent(timeout, event_sp); } bool @@ -1419,7 +1417,7 @@ Process::IsRunning () const int Process::GetExitStatus () { - Mutex::Locker locker (m_exit_status_mutex); + std::lock_guard<std::mutex> guard(m_exit_status_mutex); if (m_public_state.GetValue() == eStateExited) return m_exit_status; @@ -1429,18 +1427,18 @@ Process::GetExitStatus () const char * Process::GetExitDescription () { - Mutex::Locker locker (m_exit_status_mutex); + std::lock_guard<std::mutex> guard(m_exit_status_mutex); if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty()) return m_exit_string.c_str(); - return NULL; + return nullptr; } bool Process::SetExitStatus (int status, const char *cstr) { // Use a mutex to protect setting the exit status. - Mutex::Locker locker (m_exit_status_mutex); + std::lock_guard<std::mutex> guard(m_exit_status_mutex); Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS)); if (log) @@ -1464,14 +1462,6 @@ Process::SetExitStatus (int status, const char *cstr) else m_exit_string.clear(); - // When we exit, we don't need the input reader anymore - if (m_process_input_reader) - { - m_process_input_reader->SetIsDone(true); - m_process_input_reader->Cancel(); - m_process_input_reader.reset(); - } - // Clear the last natural stop ID since it has a strong // reference to this process m_mod_id.SetStopEventForLastNaturalStopID(EventSP()); @@ -1489,12 +1479,6 @@ Process::IsAlive () { switch (m_private_state.GetValue()) { - case eStateInvalid: - case eStateUnloaded: - case eStateDetached: - case eStateExited: - return false; - case eStateConnected: case eStateAttaching: case eStateLaunching: @@ -1504,6 +1488,8 @@ Process::IsAlive () case eStateCrashed: case eStateSuspended: return true; + default: + return false; } } @@ -1512,21 +1498,15 @@ Process::IsAlive () // found in the global target list (we want to be completely sure that the // lldb_private::Process doesn't go away before we can deliver the signal. bool -Process::SetProcessExitStatus (void *callback_baton, - lldb::pid_t pid, - bool exited, - int signo, // Zero for no signal - int exit_status // Exit value of process if signal is zero -) +Process::SetProcessExitStatus(lldb::pid_t pid, bool exited, + int signo, // Zero for no signal + int exit_status // Exit value of process if signal is zero + ) { Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS)); if (log) - log->Printf ("Process::SetProcessExitStatus (baton=%p, pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n", - callback_baton, - pid, - exited, - signo, - exit_status); + log->Printf("Process::SetProcessExitStatus (pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n", pid, + exited, signo, exit_status); if (exited) { @@ -1536,7 +1516,7 @@ Process::SetProcessExitStatus (void *callback_baton, ProcessSP process_sp (target_sp->GetProcessSP()); if (process_sp) { - const char *signal_cstr = NULL; + const char *signal_cstr = nullptr; if (signo) signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo); @@ -1557,7 +1537,7 @@ Process::UpdateThreadListIfNeeded () const StateType state = GetPrivateState(); if (StateIsStoppedState (state, true)) { - Mutex::Locker locker (m_thread_list.GetMutex ()); + std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex()); // m_thread_list does have its own mutex, but we need to // hold onto the mutex between the call to UpdateThreadList(...) // and the os->UpdateThreadList(...) so it doesn't change on us @@ -1577,7 +1557,7 @@ Process::UpdateThreadListIfNeeded () // Clear any old backing threads where memory threads might have been // backed by actual threads from the lldb_private::Process subclass size_t num_old_threads = old_thread_list.GetSize(false); - for (size_t i=0; i<num_old_threads; ++i) + for (size_t i = 0; i < num_old_threads; ++i) old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread(); // Turn off dynamic types to ensure we don't run any expressions. Objective C @@ -1626,7 +1606,7 @@ Process::UpdateThreadListIfNeeded () void Process::UpdateQueueListIfNeeded () { - if (m_system_runtime_ap.get()) + if (m_system_runtime_ap) { if (m_queue_list.GetSize() == 0 || m_queue_list_stop_id != GetLastNaturalStopID()) { @@ -1691,7 +1671,8 @@ Process::StateChangedIsExternallyHijacked() { if (IsHijackedForEvent(eBroadcastBitStateChanged)) { - if (strcmp(m_hijacking_listeners.back()->GetName(), "lldb.Process.ResumeSynchronous.hijack")) + const char *hijacking_name = GetHijackingListenerName(); + if (hijacking_name && strcmp(hijacking_name, "lldb.Process.ResumeSynchronous.hijack")) return true; } return false; @@ -1764,13 +1745,13 @@ Process::ResumeSynchronous (Stream *stream) return error; } - ListenerSP listener_sp (new Listener("lldb.Process.ResumeSynchronous.hijack")); - HijackProcessEvents(listener_sp.get()); + ListenerSP listener_sp (Listener::MakeListener("lldb.Process.ResumeSynchronous.hijack")); + HijackProcessEvents(listener_sp); Error error = PrivateResume(); if (error.Success()) { - StateType state = WaitForProcessToStop (NULL, NULL, true, listener_sp.get(), stream); + StateType state = WaitForProcessToStop (NULL, NULL, true, listener_sp, stream); const bool must_be_alive = false; // eStateExited is ok, so this must be false if (!StateIsStoppedState(state, must_be_alive)) error.SetErrorStringWithFormat("process not in stopped state after synchronous resume: %s", StateAsCString(state)); @@ -1800,8 +1781,8 @@ Process::SetPrivateState (StateType new_state) if (log) log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state)); - Mutex::Locker thread_locker(m_thread_list.GetMutex()); - Mutex::Locker locker(m_private_state.GetMutex()); + std::lock_guard<std::recursive_mutex> thread_guard(m_thread_list.GetMutex()); + std::lock_guard<std::recursive_mutex> guard(m_private_state.GetMutex()); const StateType old_state = m_private_state.GetValueNoLock (); state_changed = old_state != new_state; @@ -1844,7 +1825,7 @@ Process::SetPrivateState (StateType new_state) } // Use our target to get a shared pointer to ourselves... - if (m_finalize_called && PrivateStateThreadIsValid() == false) + if (m_finalize_called && !PrivateStateThreadIsValid()) BroadcastEvent (event_sp); else m_private_state_broadcaster.BroadcastEvent (event_sp); @@ -1899,18 +1880,18 @@ CPPLanguageRuntime * Process::GetCPPLanguageRuntime (bool retry_if_null) { LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus, retry_if_null); - if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeC_plus_plus) + if (runtime != nullptr && runtime->GetLanguageType() == eLanguageTypeC_plus_plus) return static_cast<CPPLanguageRuntime *> (runtime); - return NULL; + return nullptr; } ObjCLanguageRuntime * Process::GetObjCLanguageRuntime (bool retry_if_null) { LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC, retry_if_null); - if (runtime != NULL && runtime->GetLanguageType() == eLanguageTypeObjC) + if (runtime != nullptr && runtime->GetLanguageType() == eLanguageTypeObjC) return static_cast<ObjCLanguageRuntime *> (runtime); - return NULL; + return nullptr; } bool @@ -2167,7 +2148,7 @@ Error Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site) { Error error; - assert (bp_site != NULL); + assert(bp_site != nullptr); Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); const addr_t bp_addr = bp_site->GetLoadAddress(); if (log) @@ -2196,7 +2177,7 @@ Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site) { const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes(); - if (bp_opcode_bytes == NULL) + if (bp_opcode_bytes == nullptr) { error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode."); return error; @@ -2244,7 +2225,7 @@ Error Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site) { Error error; - assert (bp_site != NULL); + assert(bp_site != nullptr); Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); addr_t bp_addr = bp_site->GetLoadAddress(); lldb::user_id_t breakID = bp_site->GetID(); @@ -2388,7 +2369,7 @@ Process::ReadCStringFromMemory (addr_t addr, std::string &out_str, Error &error) char buf[256]; out_str.clear(); addr_t curr_addr = addr; - while (1) + while (true) { size_t length = ReadCStringFromMemory (curr_addr, buf, sizeof(buf), error); if (length == 0) @@ -2436,7 +2417,7 @@ Process::ReadStringFromMemory (addr_t addr, char *dst, size_t max_bytes, Error & // Search for a null terminator of correct size and alignment in bytes_read size_t aligned_start = total_bytes_read - total_bytes_read % type_width; for (size_t i = aligned_start; i + type_width <= total_bytes_read + bytes_read; i += type_width) - if (::strncmp(&dst[i], terminator, type_width) == 0) + if (::memcmp(&dst[i], terminator, type_width) == 0) { error.Clear(); return i; @@ -2499,7 +2480,7 @@ Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len, Erro } else { - if (dst == NULL) + if (dst == nullptr) result_error.SetErrorString("invalid arguments"); else result_error.Clear(); @@ -2510,7 +2491,7 @@ Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len, Erro size_t Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error) { - if (buf == NULL || size == 0) + if (buf == nullptr || size == 0) return 0; size_t bytes_read = 0; @@ -2536,7 +2517,8 @@ Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &err } uint64_t -Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, Error &error) +Process::ReadUnsignedIntegerFromMemory(lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value, + Error &error) { Scalar scalar; if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error)) @@ -2544,6 +2526,15 @@ Process::ReadUnsignedIntegerFromMemory (lldb::addr_t vm_addr, size_t integer_byt return fail_value; } +int64_t +Process::ReadSignedIntegerFromMemory(lldb::addr_t vm_addr, size_t integer_byte_size, int64_t fail_value, Error &error) +{ + Scalar scalar; + if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, true, scalar, error)) + return scalar.SLongLong(fail_value); + return fail_value; +} + addr_t Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error) { @@ -2594,7 +2585,7 @@ Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error) m_memory_cache.Flush (addr, size); #endif - if (buf == NULL || size == 0) + if (buf == nullptr || size == 0) return 0; m_mod_id.BumpMemoryID(); @@ -2905,7 +2896,7 @@ Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp) StateType state; // Now wait for the process to launch and return control to us, and then // call DidLaunch: - while (1) + while (true) { event_sp.reset(); state = WaitForStateChangedEventsPrivate (timeout, event_sp); @@ -2928,7 +2919,7 @@ Process::LoadOperatingSystemPlugin(bool flush) { if (flush) m_thread_list.Clear(); - m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL)); + m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr)); if (flush) Flush(); } @@ -2943,7 +2934,7 @@ Process::Launch (ProcessLaunchInfo &launch_info) m_system_runtime_ap.reset(); m_os_ap.reset(); m_process_input_reader.reset(); - m_stop_info_override_callback = NULL; + m_stop_info_override_callback = nullptr; Module *exe_module = GetTarget().GetExecutableModulePointer(); if (exe_module) @@ -2988,7 +2979,7 @@ Process::Launch (ProcessLaunchInfo &launch_info) { SetID (LLDB_INVALID_PROCESS_ID); const char *error_string = error.AsCString(); - if (error_string == NULL) + if (error_string == nullptr) error_string = "launch failed"; SetExitStatus (-1, error_string); } @@ -3001,7 +2992,7 @@ Process::Launch (ProcessLaunchInfo &launch_info) timeout_time.OffsetWithSeconds(10); StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp); - if (state == eStateInvalid || event_sp.get() == NULL) + if (state == eStateInvalid || !event_sp) { // We were able to launch the process, but we failed to // catch the initial stop. @@ -3066,8 +3057,8 @@ Process::LoadCore () Error error = DoLoadCore(); if (error.Success()) { - Listener listener ("lldb.process.load_core_listener"); - HijackProcessEvents(&listener); + ListenerSP listener_sp (Listener::MakeListener("lldb.process.load_core_listener")); + HijackProcessEvents(listener_sp); if (PrivateStateThreadIsValid ()) ResumePrivateStateThread (); @@ -3084,7 +3075,7 @@ Process::LoadCore () if (system_runtime) system_runtime->DidAttach(); - m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL)); + m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr)); // We successfully loaded a core file, now pretend we stopped so we can // show all of the threads in the core file and explore the crashed // state. @@ -3092,7 +3083,7 @@ Process::LoadCore () // Wait indefinitely for a stopped event since we just posted one above... lldb::EventSP event_sp; - listener.WaitForEvent (NULL, event_sp); + listener_sp->WaitForEvent (nullptr, event_sp); StateType state = ProcessEventData::GetStateFromEvent(event_sp.get()); if (!StateIsStoppedState (state, false)) @@ -3110,8 +3101,8 @@ Process::LoadCore () DynamicLoader * Process::GetDynamicLoader () { - if (m_dyld_ap.get() == NULL) - m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL)); + if (!m_dyld_ap) + m_dyld_ap.reset(DynamicLoader::FindPlugin(this, nullptr)); return m_dyld_ap.get(); } @@ -3135,8 +3126,8 @@ Process::GetJITLoaders () SystemRuntime * Process::GetSystemRuntime () { - if (m_system_runtime_ap.get() == NULL) - m_system_runtime_ap.reset (SystemRuntime::FindPlugin(this)); + if (!m_system_runtime_ap) + m_system_runtime_ap.reset(SystemRuntime::FindPlugin(this)); return m_system_runtime_ap.get(); } @@ -3169,31 +3160,29 @@ Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp) case eStateStopped: case eStateCrashed: + // During attach, prior to sending the eStateStopped event, + // lldb_private::Process subclasses must set the new process ID. + assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID); + // We don't want these events to be reported, so go set the ShouldReportStop here: + m_process->GetThreadList().SetShouldReportStop (eVoteNo); + + if (m_exec_count > 0) { - // During attach, prior to sending the eStateStopped event, - // lldb_private::Process subclasses must set the new process ID. - assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID); - // We don't want these events to be reported, so go set the ShouldReportStop here: - m_process->GetThreadList().SetShouldReportStop (eVoteNo); - - if (m_exec_count > 0) - { - --m_exec_count; + --m_exec_count; - if (log) - log->Printf ("Process::AttachCompletionHandler::%s state %s: reduced remaining exec count to %" PRIu32 ", requesting resume", __FUNCTION__, StateAsCString(state), m_exec_count); + if (log) + log->Printf ("Process::AttachCompletionHandler::%s state %s: reduced remaining exec count to %" PRIu32 ", requesting resume", __FUNCTION__, StateAsCString(state), m_exec_count); - RequestResume(); - return eEventActionRetry; - } - else - { - if (log) - log->Printf ("Process::AttachCompletionHandler::%s state %s: no more execs expected to start, continuing with attach", __FUNCTION__, StateAsCString(state)); + RequestResume(); + return eEventActionRetry; + } + else + { + if (log) + log->Printf ("Process::AttachCompletionHandler::%s state %s: no more execs expected to start, continuing with attach", __FUNCTION__, StateAsCString(state)); - m_process->CompleteAttach (); - return eEventActionSuccess; - } + m_process->CompleteAttach (); + return eEventActionSuccess; } break; @@ -3219,11 +3208,11 @@ Process::AttachCompletionHandler::GetExitString () return m_exit_string.c_str(); } -Listener & +ListenerSP ProcessAttachInfo::GetListenerForProcess (Debugger &debugger) { if (m_listener_sp) - return *m_listener_sp; + return m_listener_sp; else return debugger.GetListener(); } @@ -3237,7 +3226,7 @@ Process::Attach (ProcessAttachInfo &attach_info) m_jit_loaders_ap.reset(); m_system_runtime_ap.reset(); m_os_ap.reset(); - m_stop_info_override_callback = NULL; + m_stop_info_override_callback = nullptr; lldb::pid_t attach_pid = attach_info.GetProcessID(); Error error; @@ -3273,7 +3262,7 @@ Process::Attach (ProcessAttachInfo &attach_info) if (GetID() != LLDB_INVALID_PROCESS_ID) { SetID (LLDB_INVALID_PROCESS_ID); - if (error.AsCString() == NULL) + if (error.AsCString() == nullptr) error.SetErrorString("attach failed"); SetExitStatus(-1, error.AsCString()); @@ -3358,7 +3347,6 @@ Process::Attach (ProcessAttachInfo &attach_info) if (error.Success()) { - SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount())); StartPrivateStateThread(); } @@ -3368,7 +3356,7 @@ Process::Attach (ProcessAttachInfo &attach_info) SetID (LLDB_INVALID_PROCESS_ID); const char *error_string = error.AsCString(); - if (error_string == NULL) + if (error_string == nullptr) error_string = "attach failed"; SetExitStatus(-1, error_string); @@ -3381,7 +3369,7 @@ Process::Attach (ProcessAttachInfo &attach_info) void Process::CompleteAttach () { - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); + Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TARGET)); if (log) log->Printf ("Process::%s()", __FUNCTION__); @@ -3405,11 +3393,11 @@ Process::CompleteAttach () // We just attached. If we have a platform, ask it for the process architecture, and if it isn't // the same as the one we've already set, switch architectures. PlatformSP platform_sp (GetTarget().GetPlatform ()); - assert (platform_sp.get()); + assert(platform_sp); if (platform_sp) { const ArchSpec &target_arch = GetTarget().GetArchitecture(); - if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture (target_arch, false, NULL)) + if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture(target_arch, false, nullptr)) { ArchSpec platform_arch; platform_sp = platform_sp->GetPlatformForArchitecture (target_arch, &platform_arch); @@ -3424,7 +3412,7 @@ Process::CompleteAttach () else if (!process_arch.IsValid()) { ProcessInstanceInfo process_info; - platform_sp->GetProcessInfo (GetID(), process_info); + GetProcessInfo(process_info); const ArchSpec &process_arch = process_info.GetArchitecture(); if (process_arch.IsValid() && !GetTarget().GetArchitecture().IsExactMatch(process_arch)) { @@ -3467,10 +3455,10 @@ Process::CompleteAttach () } } - m_os_ap.reset (OperatingSystem::FindPlugin (this, NULL)); + m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr)); // Figure out which one is the executable, and set that in our target: const ModuleList &target_modules = GetTarget().GetImages(); - Mutex::Locker modules_locker(target_modules.GetMutex()); + std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); size_t num_modules = target_modules.GetSize(); ModuleSP new_executable_module_sp; @@ -3514,7 +3502,7 @@ Process::ConnectRemote (Stream *strm, const char *remote_url) if (GetID() != LLDB_INVALID_PROCESS_ID) { EventSP event_sp; - StateType state = WaitForProcessStopPrivate(NULL, event_sp); + StateType state = WaitForProcessStopPrivate(nullptr, event_sp); if (state == eStateStopped || state == eStateCrashed) { @@ -3525,7 +3513,6 @@ Process::ConnectRemote (Stream *strm, const char *remote_url) // This delays passing the stopped event to listeners till // CompleteAttach gets a chance to complete... HandlePrivateEvent (event_sp); - } } @@ -3607,8 +3594,8 @@ Process::Halt (bool clear_thread_plans, bool use_run_lock) // own. m_clear_thread_plans_on_stop |= clear_thread_plans; - Listener halt_listener ("lldb.process.halt_listener"); - HijackProcessEvents(&halt_listener); + ListenerSP halt_listener_sp (Listener::MakeListener("lldb.process.halt_listener")); + HijackProcessEvents(halt_listener_sp); EventSP event_sp; @@ -3628,7 +3615,7 @@ Process::Halt (bool clear_thread_plans, bool use_run_lock) TimeValue timeout_time; timeout_time = TimeValue::Now(); timeout_time.OffsetWithSeconds(10); - StateType state = WaitForProcessToStop(&timeout_time, &event_sp, true, &halt_listener, + StateType state = WaitForProcessToStop(&timeout_time, &event_sp, true, halt_listener_sp, nullptr, use_run_lock); RestoreProcessEvents(); @@ -3653,8 +3640,8 @@ Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) if (log) log->Printf("Process::%s() About to stop.", __FUNCTION__); - ListenerSP listener_sp (new Listener("lldb.Process.StopForDestroyOrDetach.hijack")); - HijackProcessEvents(listener_sp.get()); + ListenerSP listener_sp (Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack")); + HijackProcessEvents(listener_sp); SendAsyncInterrupt(); @@ -3662,7 +3649,7 @@ Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) TimeValue timeout (TimeValue::Now()); timeout.OffsetWithSeconds(10); - StateType state = WaitForProcessToStop (&timeout, &exit_event_sp, true, listener_sp.get()); + StateType state = WaitForProcessToStop (&timeout, &exit_event_sp, true, listener_sp); RestoreProcessEvents(); @@ -3688,7 +3675,7 @@ Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp) StateType private_state = m_private_state.GetValue(); if (private_state != eStateStopped) { - return error; + return Error("Attempt to stop the target in order to detach timed out. State = %s", StateAsCString(GetState())); } } } @@ -3888,7 +3875,7 @@ Process::ShouldBroadcastEvent (Event *event_ptr) m_stdio_communication.StopReadThread(); m_stdin_forward = false; - // fall-through + LLVM_FALLTHROUGH; case eStateConnected: case eStateAttaching: case eStateLaunching: @@ -3945,7 +3932,6 @@ Process::ShouldBroadcastEvent (Event *event_ptr) case eStateStopped: case eStateCrashed: case eStateSuspended: - { // We've stopped. First see if we're going to restart the target. // If we are going to stop, then we always broadcast the event. // If we aren't going to stop, let the thread plans decide if we're going to report this event. @@ -3974,7 +3960,7 @@ Process::ShouldBroadcastEvent (Event *event_ptr) // So in that case just report the event. if (!was_restarted) - should_resume = m_thread_list.ShouldStop (event_ptr) == false; + should_resume = !m_thread_list.ShouldStop(event_ptr); if (was_restarted || should_resume || m_resume_requested) { @@ -4011,8 +3997,7 @@ Process::ShouldBroadcastEvent (Event *event_ptr) SynchronouslyNotifyStateChanged (state); } } - } - break; + break; } // Forcing the next event delivery is a one shot deal. So reset it here. @@ -4069,8 +4054,8 @@ Process::StartPrivateStateThread (bool is_secondary_thread) } // Create the private state thread, and start it running. - PrivateStateThreadArgs args = {this, is_secondary_thread}; - m_private_state_thread = ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread, (void *) &args, NULL, 8 * 1024 * 1024); + PrivateStateThreadArgs *args_ptr = new PrivateStateThreadArgs(this, is_secondary_thread); + m_private_state_thread = ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread, (void *) args_ptr, nullptr, 8 * 1024 * 1024); if (m_private_state_thread.IsJoinable()) { ResumePrivateStateThread(); @@ -4095,7 +4080,7 @@ Process::ResumePrivateStateThread () void Process::StopPrivateStateThread () { - if (PrivateStateThreadIsValid ()) + if (m_private_state_thread.IsJoinable ()) ControlPrivateStateThread (eBroadcastInternalStateControlStop); else { @@ -4117,47 +4102,52 @@ Process::ControlPrivateStateThread (uint32_t signal) if (log) log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal); - // Signal the private state thread. First we should copy this is case the - // thread starts exiting since the private state thread will NULL this out - // when it exits - HostThread private_state_thread(m_private_state_thread); - if (private_state_thread.IsJoinable()) + // Signal the private state thread + if (m_private_state_thread.IsJoinable()) { - TimeValue timeout_time; - bool timed_out; - - m_private_state_control_broadcaster.BroadcastEvent (signal, NULL); - - timeout_time = TimeValue::Now(); - timeout_time.OffsetWithSeconds(2); + // Broadcast the event. + // It is important to do this outside of the if below, because + // it's possible that the thread state is invalid but that the + // thread is waiting on a control event instead of simply being + // on its way out (this should not happen, but it apparently can). if (log) log->Printf ("Sending control event of type: %d.", signal); - m_private_state_control_wait.WaitForValueEqualTo (true, &timeout_time, &timed_out); - m_private_state_control_wait.SetValue (false, eBroadcastNever); + std::shared_ptr<EventDataReceipt> event_receipt_sp(new EventDataReceipt()); + m_private_state_control_broadcaster.BroadcastEvent(signal, event_receipt_sp); - if (signal == eBroadcastInternalStateControlStop) + // Wait for the event receipt or for the private state thread to exit + bool receipt_received = false; + if (PrivateStateThreadIsValid()) { - if (timed_out) - { - Error error = private_state_thread.Cancel(); - if (log) - log->Printf ("Timed out responding to the control event, cancel got error: \"%s\".", error.AsCString()); - } - else + while (!receipt_received) { - if (log) - log->Printf ("The control event killed the private state thread without having to cancel."); + bool timed_out = false; + TimeValue timeout_time; + timeout_time = TimeValue::Now(); + timeout_time.OffsetWithSeconds(2); + // Check for a receipt for 2 seconds and then check if the private state + // thread is still around. + receipt_received = event_receipt_sp->WaitForEventReceived (&timeout_time, &timed_out); + if (!receipt_received) + { + // Check if the private state thread is still around. If it isn't then we are done waiting + if (!PrivateStateThreadIsValid()) + break; // Private state thread exited or is exiting, we are done + } } + } + if (signal == eBroadcastInternalStateControlStop) + { thread_result_t result = NULL; - private_state_thread.Join(&result); + m_private_state_thread.Join(&result); m_private_state_thread.Reset(); } } else { if (log) - log->Printf ("Private state thread already dead, no need to signal it to stop."); + log->Printf("Private state thread already dead, no need to signal it to stop."); } } @@ -4165,9 +4155,9 @@ void Process::SendAsyncInterrupt () { if (PrivateStateThreadIsValid()) - m_private_state_broadcaster.BroadcastEvent (Process::eBroadcastBitInterrupt, NULL); + m_private_state_broadcaster.BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr); else - BroadcastEvent (Process::eBroadcastBitInterrupt, NULL); + BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr); } void @@ -4179,7 +4169,7 @@ Process::HandlePrivateEvent (EventSP &event_sp) const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get()); // First check to see if anybody wants a shot at this event: - if (m_next_event_action_ap.get() != NULL) + if (m_next_event_action_ap) { NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp); if (log) @@ -4188,7 +4178,7 @@ Process::HandlePrivateEvent (EventSP &event_sp) switch (action_result) { case NextEventAction::eEventActionSuccess: - SetNextEventAction(NULL); + SetNextEventAction(nullptr); break; case NextEventAction::eEventActionRetry: @@ -4202,10 +4192,10 @@ Process::HandlePrivateEvent (EventSP &event_sp) { // FIXME: should cons up an exited event, and discard this one. SetExitStatus(0, m_next_event_action_ap->GetExitString()); - SetNextEventAction(NULL); + SetNextEventAction(nullptr); return; } - SetNextEventAction(NULL); + SetNextEventAction(nullptr); break; } } @@ -4273,7 +4263,7 @@ Process::HandlePrivateEvent (EventSP &event_sp) // events) and we do need the IO handler to be pushed and popped // correctly. - if (is_hijacked || GetTarget().GetDebugger().IsHandlingEvents() == false) + if (is_hijacked || !GetTarget().GetDebugger().IsHandlingEvents()) PopProcessIOHandler (); } } @@ -4312,8 +4302,9 @@ Process::HaltPrivate() thread_result_t Process::PrivateStateThread (void *arg) { - PrivateStateThreadArgs *real_args = static_cast<PrivateStateThreadArgs *> (arg); - thread_result_t result = real_args->process->RunPrivateStateThread(real_args->is_secondary_thread); + PrivateStateThreadArgs real_args = *static_cast<PrivateStateThreadArgs *> (arg); + free (arg); + thread_result_t result = real_args.process->RunPrivateStateThread(real_args.is_secondary_thread); return result; } @@ -4321,7 +4312,6 @@ thread_result_t Process::RunPrivateStateThread (bool is_secondary_thread) { bool control_only = true; - m_private_state_control_wait.SetValue (false, eBroadcastNever); Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); if (log) @@ -4333,7 +4323,7 @@ Process::RunPrivateStateThread (bool is_secondary_thread) while (!exit_now) { EventSP event_sp; - WaitForEventsPrivate (NULL, event_sp, control_only); + WaitForEventsPrivate(nullptr, event_sp, control_only); if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster)) { if (log) @@ -4356,7 +4346,6 @@ Process::RunPrivateStateThread (bool is_secondary_thread) break; } - m_private_state_control_wait.SetValue (true, eBroadcastAlways); continue; } else if (event_sp->GetType() == eBroadcastBitInterrupt) @@ -4367,7 +4356,7 @@ Process::RunPrivateStateThread (bool is_secondary_thread) log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt while attaching - forwarding interrupt.", __FUNCTION__, static_cast<void*>(this), GetID()); - BroadcastEvent (eBroadcastBitInterrupt, NULL); + BroadcastEvent(eBroadcastBitInterrupt, nullptr); } else if(StateIsRunningState(m_last_broadcast_state)) { @@ -4452,8 +4441,6 @@ Process::RunPrivateStateThread (bool is_secondary_thread) // try to change it on the way out. if (!is_secondary_thread) m_public_run_lock.SetStopped(); - m_private_state_control_wait.SetValue (true, eBroadcastAlways); - m_private_state_thread.Reset(); return NULL; } @@ -4610,7 +4597,7 @@ Process::ProcessEventData::DoOnRemoval (Event *event_ptr) this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr); } - if (still_should_stop == false) + if (!still_should_stop) still_should_stop = this_thread_wants_to_stop; } } @@ -4660,7 +4647,7 @@ Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr) if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString()) return static_cast <const ProcessEventData *> (event_ptr->GetData()); } - return NULL; + return nullptr; } ProcessSP @@ -4677,7 +4664,7 @@ StateType Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr) { const ProcessEventData *data = GetEventDataFromEvent (event_ptr); - if (data == NULL) + if (data == nullptr) return eStateInvalid; else return data->GetState(); @@ -4687,7 +4674,7 @@ bool Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr) { const ProcessEventData *data = GetEventDataFromEvent (event_ptr); - if (data == NULL) + if (data == nullptr) return false; else return data->GetRestarted(); @@ -4697,7 +4684,7 @@ void Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value) { ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); - if (data != NULL) + if (data != nullptr) data->SetRestarted(new_value); } @@ -4705,7 +4692,7 @@ size_t Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr) { ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); - if (data != NULL) + if (data != nullptr) return data->GetNumRestartedReasons(); else return 0; @@ -4715,17 +4702,17 @@ const char * Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr, size_t idx) { ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); - if (data != NULL) + if (data != nullptr) return data->GetRestartedReasonAtIndex(idx); else - return NULL; + return nullptr; } void Process::ProcessEventData::AddRestartedReason (Event *event_ptr, const char *reason) { ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); - if (data != NULL) + if (data != nullptr) data->AddRestartedReason(reason); } @@ -4733,7 +4720,7 @@ bool Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr) { const ProcessEventData *data = GetEventDataFromEvent (event_ptr); - if (data == NULL) + if (data == nullptr) return false; else return data->GetInterrupted (); @@ -4743,7 +4730,7 @@ void Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value) { ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr)); - if (data != NULL) + if (data != nullptr) data->SetInterrupted(new_value); } @@ -4770,8 +4757,8 @@ Process::CalculateExecutionContext (ExecutionContext &exe_ctx) { exe_ctx.SetTargetPtr (&GetTarget()); exe_ctx.SetProcessPtr (this); - exe_ctx.SetThreadPtr(NULL); - exe_ctx.SetFramePtr (NULL); + exe_ctx.SetThreadPtr(nullptr); + exe_ctx.SetFramePtr(nullptr); } //uint32_t @@ -4791,11 +4778,11 @@ Process::CalculateExecutionContext (ExecutionContext &exe_ctx) //{ // return Host::GetArchSpecForExistingProcess (process_name); //} -// + void Process::AppendSTDOUT (const char * s, size_t len) { - Mutex::Locker locker (m_stdio_communication_mutex); + std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex); m_stdout_data.append (s, len); BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (shared_from_this(), GetState())); } @@ -4803,7 +4790,7 @@ Process::AppendSTDOUT (const char * s, size_t len) void Process::AppendSTDERR (const char * s, size_t len) { - Mutex::Locker locker (m_stdio_communication_mutex); + std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex); m_stderr_data.append (s, len); BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (shared_from_this(), GetState())); } @@ -4811,7 +4798,7 @@ Process::AppendSTDERR (const char * s, size_t len) void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) { - Mutex::Locker locker (m_profile_data_comm_mutex); + std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex); m_profile_data.push_back(one_profile_data); BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState())); } @@ -4819,7 +4806,7 @@ Process::BroadcastAsyncProfileData(const std::string &one_profile_data) size_t Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error) { - Mutex::Locker locker(m_profile_data_comm_mutex); + std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex); if (m_profile_data.empty()) return 0; @@ -4854,7 +4841,7 @@ Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error) size_t Process::GetSTDOUT (char *buf, size_t buf_size, Error &error) { - Mutex::Locker locker(m_stdio_communication_mutex); + std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex); size_t bytes_available = m_stdout_data.size(); if (bytes_available > 0) { @@ -4881,7 +4868,7 @@ Process::GetSTDOUT (char *buf, size_t buf_size, Error &error) size_t Process::GetSTDERR (char *buf, size_t buf_size, Error &error) { - Mutex::Locker locker(m_stdio_communication_mutex); + std::lock_guard<std::recursive_mutex> gaurd(m_stdio_communication_mutex); size_t bytes_available = m_stderr_data.size(); if (bytes_available > 0) { @@ -4952,6 +4939,7 @@ public: // FD_ZERO, FD_SET are not supported on windows #ifndef _WIN32 const int pipe_read_fd = m_pipe.GetReadFileDescriptor(); + m_is_running = true; while (!GetIsDone()) { fd_set read_fdset; @@ -4959,7 +4947,8 @@ public: FD_SET (read_fd, &read_fdset); FD_SET (pipe_read_fd, &read_fdset); const int nfds = std::max<int>(read_fd, pipe_read_fd) + 1; - int num_set_fds = select (nfds, &read_fdset, NULL, NULL, NULL); + int num_set_fds = select(nfds, &read_fdset, nullptr, nullptr, nullptr); + if (num_set_fds < 0) { const int select_errno = errno; @@ -5003,6 +4992,7 @@ public: } } } + m_is_running = false; #endif terminal_state.Restore(); } @@ -5010,9 +5000,24 @@ public: void Cancel () override { - char ch = 'q'; // Send 'q' for quit - size_t bytes_written = 0; - m_pipe.Write(&ch, 1, bytes_written); + SetIsDone(true); + // Only write to our pipe to cancel if we are in IOHandlerProcessSTDIO::Run(). + // We can end up with a python command that is being run from the command + // interpreter: + // + // (lldb) step_process_thousands_of_times + // + // In this case the command interpreter will be in the middle of handling + // the command and if the process pushes and pops the IOHandler thousands + // of times, we can end up writing to m_pipe without ever consuming the + // bytes from the pipe in IOHandlerProcessSTDIO::Run() and end up + // deadlocking when the pipe gets fed up and blocks until data is consumed. + if (m_is_running) + { + char ch = 'q'; // Send 'q' for quit + size_t bytes_written = 0; + m_pipe.Write(&ch, 1, bytes_written); + } } bool @@ -5059,6 +5064,7 @@ protected: File m_read_file; // Read from this file (usually actual STDIN for LLDB File m_write_file; // Write to this file (usually the master pty for getting io to debuggee) Pipe m_pipe; + std::atomic<bool> m_is_running; }; void @@ -5068,7 +5074,7 @@ Process::SetSTDIOFileDescriptor (int fd) std::unique_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (fd, true)); - if (conn_ap.get()) + if (conn_ap) { m_stdio_communication.SetConnection (conn_ap.release()); if (m_stdio_communication.IsConnected()) @@ -5078,7 +5084,7 @@ Process::SetSTDIOFileDescriptor (int fd) // Now read thread is set up, set up input reader. - if (!m_process_input_reader.get()) + if (!m_process_input_reader) m_process_input_reader.reset (new IOHandlerProcessSTDIO (this, fd)); } } @@ -5180,41 +5186,41 @@ namespace } // anonymous namespace ExpressionResults -Process::RunThreadPlan (ExecutionContext &exe_ctx, - lldb::ThreadPlanSP &thread_plan_sp, - const EvaluateExpressionOptions &options, - Stream &errors) +Process::RunThreadPlan(ExecutionContext &exe_ctx, lldb::ThreadPlanSP &thread_plan_sp, + const EvaluateExpressionOptions &options, DiagnosticManager &diagnostic_manager) { ExpressionResults return_value = eExpressionSetupError; + + std::lock_guard<std::mutex> run_thread_plan_locker(m_run_thread_plan_lock); - if (thread_plan_sp.get() == NULL) + if (!thread_plan_sp) { - errors.Printf("RunThreadPlan called with empty thread plan."); + diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called with empty thread plan."); return eExpressionSetupError; } - if (!thread_plan_sp->ValidatePlan(NULL)) + if (!thread_plan_sp->ValidatePlan(nullptr)) { - errors.Printf ("RunThreadPlan called with an invalid thread plan."); + diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called with an invalid thread plan."); return eExpressionSetupError; } if (exe_ctx.GetProcessPtr() != this) { - errors.Printf("RunThreadPlan called on wrong process."); + diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called on wrong process."); return eExpressionSetupError; } Thread *thread = exe_ctx.GetThreadPtr(); - if (thread == NULL) + if (thread == nullptr) { - errors.Printf("RunThreadPlan called with invalid thread."); + diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called with invalid thread."); return eExpressionSetupError; } // We need to change some of the thread plan attributes for the thread plan runner. This will restore them // when we are done: - + RestorePlanState thread_plan_restorer(thread_plan_sp); // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes. @@ -5231,7 +5237,8 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, if (m_private_state.GetValue() != eStateStopped) { - errors.Printf ("RunThreadPlan called while the private state was not stopped."); + diagnostic_manager.PutCString(eDiagnosticSeverityError, + "RunThreadPlan called while the private state was not stopped."); return eExpressionSetupError; } @@ -5240,11 +5247,12 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, StackFrameSP selected_frame_sp = thread->GetSelectedFrame(); if (!selected_frame_sp) { - thread->SetSelectedFrame(0); + thread->SetSelectedFrame(nullptr); selected_frame_sp = thread->GetSelectedFrame(); if (!selected_frame_sp) { - errors.Printf("RunThreadPlan called without a selected frame on thread %d", thread_idx_id); + diagnostic_manager.Printf(eDiagnosticSeverityError, + "RunThreadPlan called without a selected frame on thread %d", thread_idx_id); return eExpressionSetupError; } } @@ -5313,7 +5321,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, return eExpressionStoppedForDebug; } - Listener listener("lldb.process.listener.run-thread-plan"); + ListenerSP listener_sp(Listener::MakeListener("lldb.process.listener.run-thread-plan")); lldb::EventSP event_to_broadcast_sp; @@ -5324,7 +5332,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, // If the event needs to propagate beyond the hijacker (e.g., the process exits during execution), then the event // is put into event_to_broadcast_sp for rebroadcasting. - ProcessEventHijacker run_thread_plan_hijacker (*this, &listener); + ProcessEventHijacker run_thread_plan_hijacker (*this, listener_sp); if (log) { @@ -5340,7 +5348,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, lldb::EventSP event_sp; lldb::StateType stop_state = lldb::eStateInvalid; - TimeValue* timeout_ptr = NULL; + TimeValue* timeout_ptr = nullptr; TimeValue real_timeout; bool before_first_timeout = true; // This is set to false the first time that we have to halt the target. @@ -5386,7 +5394,9 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, { if (timeout_usec < option_one_thread_timeout) { - errors.Printf("RunThreadPlan called without one thread timeout greater than total timeout"); + diagnostic_manager.PutCString( + eDiagnosticSeverityError, + "RunThreadPlan called without one thread timeout greater than total timeout"); return eExpressionSetupError; } computed_one_thread_timeout = option_one_thread_timeout; @@ -5414,10 +5424,11 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, // Are there cases where we might want to run the remaining events here, and then try to // call the function? That's probably being too tricky for our own good. - Event *other_events = listener.PeekAtNextEvent(); - if (other_events != NULL) + Event *other_events = listener_sp->PeekAtNextEvent(); + if (other_events != nullptr) { - errors.Printf("Calling RunThreadPlan with pending events on the queue."); + diagnostic_manager.PutCString(eDiagnosticSeverityError, + "RunThreadPlan called with pending events on the queue."); return eExpressionSetupError; } @@ -5441,7 +5452,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, TimeValue one_thread_timeout; TimeValue final_timeout; - while (1) + while (true) { // We usually want to resume the process if we get to the top of the loop. // The only exception is if we get two running events with no intervening @@ -5459,12 +5470,12 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, if (do_resume) { num_resumes++; - Error resume_error = PrivateResume (); + Error resume_error = PrivateResume(); if (!resume_error.Success()) { - errors.Printf("Error resuming inferior the %d time: \"%s\".\n", - num_resumes, - resume_error.AsCString()); + diagnostic_manager.Printf(eDiagnosticSeverityError, + "couldn't resume inferior the %d time: \"%s\".", num_resumes, + resume_error.AsCString()); return_value = eExpressionSetupError; break; } @@ -5473,14 +5484,15 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, TimeValue resume_timeout = TimeValue::Now(); resume_timeout.OffsetWithMicroSeconds(500000); - got_event = listener.WaitForEvent(&resume_timeout, event_sp); + got_event = listener_sp->WaitForEvent(&resume_timeout, event_sp); if (!got_event) { if (log) - log->Printf ("Process::RunThreadPlan(): didn't get any event after resume %d, exiting.", - num_resumes); + log->Printf("Process::RunThreadPlan(): didn't get any event after resume %" PRIu32 ", exiting.", + num_resumes); - errors.Printf("Didn't get any event after resume %d, exiting.", num_resumes); + diagnostic_manager.Printf(eDiagnosticSeverityError, + "didn't get any event after resume %" PRIu32 ", exiting.", num_resumes); return_value = eExpressionSetupError; break; } @@ -5513,8 +5525,9 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, Halt(clear_thread_plans, use_run_lock); } - errors.Printf("Didn't get running event after initial resume, got %s instead.", - StateAsCString(stop_state)); + diagnostic_manager.Printf(eDiagnosticSeverityError, + "didn't get running event after initial resume, got %s instead.", + StateAsCString(stop_state)); return_value = eExpressionSetupError; break; } @@ -5544,7 +5557,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, else { if (timeout_usec == 0) - timeout_ptr = NULL; + timeout_ptr = nullptr; else { final_timeout = TimeValue::Now(); @@ -5556,7 +5569,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, else { if (timeout_usec == 0) - timeout_ptr = NULL; + timeout_ptr = nullptr; else { final_timeout = TimeValue::Now(); @@ -5595,11 +5608,11 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, } else #endif - got_event = listener.WaitForEvent (timeout_ptr, event_sp); + got_event = listener_sp->WaitForEvent (timeout_ptr, event_sp); if (got_event) { - if (event_sp.get()) + if (event_sp) { bool keep_going = false; if (event_sp->GetType() == eBroadcastBitInterrupt) @@ -5608,9 +5621,10 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, const bool use_run_lock = false; Halt(clear_thread_plans, use_run_lock); return_value = eExpressionInterrupted; - errors.Printf ("Execution halted by user interrupt."); + diagnostic_manager.PutCString(eDiagnosticSeverityRemark, "execution halted by user interrupt."); if (log) - log->Printf ("Process::RunThreadPlan(): Got interrupted by eBroadcastBitInterrupted, exiting."); + log->Printf( + "Process::RunThreadPlan(): Got interrupted by eBroadcastBitInterrupted, exiting."); break; } else @@ -5713,7 +5727,8 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, if (stop_state == eStateExited) event_to_broadcast_sp = event_sp; - errors.Printf ("Execution stopped with unexpected state.\n"); + diagnostic_manager.PutCString(eDiagnosticSeverityError, + "execution stopped with unexpected state."); return_value = eExpressionInterrupted; break; } @@ -5795,7 +5810,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, real_timeout = TimeValue::Now(); real_timeout.OffsetWithMicroSeconds(500000); - got_event = listener.WaitForEvent(&real_timeout, event_sp); + got_event = listener_sp->WaitForEvent(&real_timeout, event_sp); if (got_event) { @@ -5943,7 +5958,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, StreamString ts; - const char *event_explanation = NULL; + const char *event_explanation = nullptr; do { @@ -6091,7 +6106,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx, if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid()) { // We were able to restore the selected thread, now restore the frame: - Mutex::Locker lock(GetThreadList().GetMutex()); + std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex()); StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id); if (old_frame_sp) GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get()); @@ -6196,7 +6211,7 @@ Process::GetThreadStatus (Stream &strm, std::vector<lldb::tid_t> thread_id_array; //Scope for thread list locker; { - Mutex::Locker locker (GetThreadList().GetMutex()); + std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex()); ThreadList &curr_thread_list = GetThreadList(); num_threads = curr_thread_list.GetSize(); uint32_t idx; @@ -6213,7 +6228,7 @@ Process::GetThreadStatus (Stream &strm, if (only_threads_with_stop_reason) { StopInfoSP stop_info_sp = thread_sp->GetStopInfo(); - if (stop_info_sp.get() == NULL || !stop_info_sp->IsValid()) + if (!stop_info_sp || !stop_info_sp->IsValid()) continue; } thread_sp->GetStatus (strm, @@ -6259,7 +6274,7 @@ Process::RunPreResumeActions () struct PreResumeCallbackAndBaton action = m_pre_resume_actions.back(); m_pre_resume_actions.pop_back(); bool this_result = action.callback (action.baton); - if (result == true) + if (result) result = this_result; } return result; @@ -6312,7 +6327,7 @@ Process::DidExec () m_instrumentation_runtimes.clear(); m_thread_list.DiscardThreadPlans(); m_memory_cache.Clear(true); - m_stop_info_override_callback = NULL; + m_stop_info_override_callback = nullptr; DoDidExec(); CompleteAttach (); // Flush the process (threads and all stack frames) after running CompleteAttach() @@ -6389,14 +6404,17 @@ Process::ModulesDidLoad (ModuleList &module_list) for (const auto &pair: language_runtimes) { // We must check language_runtime_sp to make sure it is not - // NULL as we might cache the fact that we didn't have a + // nullptr as we might cache the fact that we didn't have a // language runtime for a language. LanguageRuntimeSP language_runtime_sp = pair.second; if (language_runtime_sp) language_runtime_sp->ModulesDidLoad(module_list); } - LoadOperatingSystemPlugin(false); + // If we don't have an operating system plug-in, try to load one since + // loading shared libraries might cause a new one to try and load + if (!m_os_ap) + LoadOperatingSystemPlugin(false); } void @@ -6405,10 +6423,10 @@ Process::PrintWarning (uint64_t warning_type, const void *repeat_key, const char bool print_warning = true; StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream(); - if (stream_sp.get() == nullptr) + if (!stream_sp) return; if (warning_type == eWarningsOptimization - && GetWarningsOptimization() == false) + && !GetWarningsOptimization()) { return; } @@ -6446,16 +6464,28 @@ Process::PrintWarning (uint64_t warning_type, const void *repeat_key, const char void Process::PrintWarningOptimization (const SymbolContext &sc) { - if (GetWarningsOptimization() == true - && sc.module_sp.get() - && sc.module_sp->GetFileSpec().GetFilename().IsEmpty() == false + if (GetWarningsOptimization() + && sc.module_sp + && !sc.module_sp->GetFileSpec().GetFilename().IsEmpty() && sc.function - && sc.function->GetIsOptimized() == true) + && sc.function->GetIsOptimized()) { 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()); } } +bool +Process::GetProcessInfo(ProcessInstanceInfo &info) +{ + info.Clear(); + + PlatformSP platform_sp = GetTarget().GetPlatform(); + if (! platform_sp) + return false; + + return platform_sp->GetProcessInfo(GetID(), info); +} + ThreadCollectionSP Process::GetHistoryThreads(lldb::addr_t addr) { @@ -6463,7 +6493,7 @@ Process::GetHistoryThreads(lldb::addr_t addr) const MemoryHistorySP &memory_history = MemoryHistory::FindPlugin(shared_from_this()); - if (! memory_history.get()) { + if (!memory_history) { return threads; } @@ -6521,13 +6551,13 @@ Process::AdvanceAddressToNextBranchInstruction (Address default_stop_addr, Addre { Target &target = GetTarget(); DisassemblerSP disassembler_sp; - InstructionList *insn_list = NULL; + InstructionList *insn_list = nullptr; Address retval = default_stop_addr; - if (target.GetUseFastStepping() == false) + if (!target.GetUseFastStepping()) return retval; - if (default_stop_addr.IsValid() == false) + if (!default_stop_addr.IsValid()) return retval; ExecutionContext exe_ctx (this); @@ -6540,10 +6570,10 @@ Process::AdvanceAddressToNextBranchInstruction (Address default_stop_addr, Addre exe_ctx, range_bounds, prefer_file_cache); - if (disassembler_sp.get()) + if (disassembler_sp) insn_list = &disassembler_sp->GetInstructionList(); - if (insn_list == NULL) + if (insn_list == nullptr) { return retval; } @@ -6569,11 +6599,38 @@ Process::AdvanceAddressToNextBranchInstruction (Address default_stop_addr, Addre } } - if (disassembler_sp.get()) + return retval; +} + +Error +Process::GetMemoryRegions (std::vector<lldb::MemoryRegionInfoSP>& region_list) +{ + + Error error; + + lldb::addr_t range_base = 0; + lldb::addr_t range_end = 0; + + region_list.clear(); + do { - // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions. - disassembler_sp->GetInstructionList().Clear(); - } + lldb::MemoryRegionInfoSP region_info( new lldb_private::MemoryRegionInfo() ); + error = GetMemoryRegionInfo (range_end, *region_info); + // GetMemoryRegionInfo should only return an error if it is unimplemented. + if (error.Fail()) + { + region_list.clear(); + break; + } + + range_base = region_info->GetRange().GetRangeBase(); + range_end = region_info->GetRange().GetRangeEnd(); + if( region_info->GetMapped() == MemoryRegionInfo::eYes ) + { + region_list.push_back(region_info); + } + } while (range_end != LLDB_INVALID_ADDRESS); + + return error; - return retval; } |