diff options
50 files changed, 814 insertions, 467 deletions
diff --git a/lldb/include/lldb/API/SBListener.h b/lldb/include/lldb/API/SBListener.h index 924f8109f63..e74d318ea11 100644 --- a/lldb/include/lldb/API/SBListener.h +++ b/lldb/include/lldb/API/SBListener.h @@ -106,8 +106,6 @@ protected: friend class SBLaunchInfo; friend class SBTarget; - SBListener (lldb_private::Listener &listener); - SBListener (const lldb::ListenerSP &listener_sp); lldb::ListenerSP @@ -124,20 +122,11 @@ private: lldb_private::Listener * get() const; - lldb_private::Listener & - ref() const; - - lldb_private::Listener & - operator *(); - - const lldb_private::Listener & - operator *() const; - void - reset(lldb_private::Listener *listener, bool transfer_ownership); + reset(lldb::ListenerSP listener_sp); lldb::ListenerSP m_opaque_sp; - lldb_private::Listener *m_opaque_ptr; + lldb_private::Listener *m_unused_ptr; }; } // namespace lldb diff --git a/lldb/include/lldb/Core/Broadcaster.h b/lldb/include/lldb/Core/Broadcaster.h index ce5119b1253..8a61432ee8e 100644 --- a/lldb/include/lldb/Core/Broadcaster.h +++ b/lldb/include/lldb/Core/Broadcaster.h @@ -19,9 +19,8 @@ // Other libraries and framework includes // Project includes #include "lldb/lldb-private.h" -//#include "lldb/Core/Flags.h" #include "lldb/Core/ConstString.h" -#include "lldb/Core/Listener.h" +#include "lldb/Host/Mutex.h" namespace lldb_private { @@ -82,37 +81,47 @@ private: uint32_t m_event_bits; }; -class BroadcasterManager +class BroadcasterManager : + public std::enable_shared_from_this<BroadcasterManager> { public: friend class Listener; +protected: BroadcasterManager (); - +public: + // Listeners hold onto weak pointers to their broadcaster managers. So they must be + // made into shared pointers, which you do with MakeBroadcasterManager. + + static lldb::BroadcasterManagerSP + MakeBroadcasterManager(); + ~BroadcasterManager() = default; uint32_t - RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec); + RegisterListenerForEvents (lldb::ListenerSP listener_sp, BroadcastEventSpec event_spec); bool - UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec); + UnregisterListenerForEvents (lldb::ListenerSP listener_sp, BroadcastEventSpec event_spec); - Listener * + lldb::ListenerSP GetListenerForEventSpec (BroadcastEventSpec event_spec) const; void SignUpListenersForBroadcaster (Broadcaster &broadcaster); void - RemoveListener (Listener &Listener); + RemoveListener (lldb::ListenerSP listener_sp); + + void + RemoveListener (Listener *listener); -protected: void Clear(); private: - typedef std::pair<BroadcastEventSpec, Listener *> event_listener_key; - typedef std::map<BroadcastEventSpec, Listener *> collection; - typedef std::set<Listener *> listener_collection; + typedef std::pair<BroadcastEventSpec, lldb::ListenerSP> event_listener_key; + typedef std::map<BroadcastEventSpec, lldb::ListenerSP> collection; + typedef std::set<lldb::ListenerSP> listener_collection; collection m_event_map; listener_collection m_listeners; @@ -162,9 +171,9 @@ private: { public: ListenerMatchesAndSharedBits (BroadcastEventSpec broadcaster_spec, - const Listener &listener) : + const lldb::ListenerSP listener_sp) : m_broadcaster_spec (broadcaster_spec), - m_listener (&listener) + m_listener_sp (listener_sp) { } @@ -174,19 +183,19 @@ private: { return (input.first.GetBroadcasterClass() == m_broadcaster_spec.GetBroadcasterClass() && (input.first.GetEventBits() & m_broadcaster_spec.GetEventBits()) != 0 - && input.second == m_listener); + && input.second == m_listener_sp); } private: BroadcastEventSpec m_broadcaster_spec; - const Listener *m_listener; + const lldb::ListenerSP m_listener_sp; }; class ListenerMatches { public: - ListenerMatches (const Listener &in_listener) : - m_listener (&in_listener) + ListenerMatches (const lldb::ListenerSP in_listener_sp) : + m_listener_sp (in_listener_sp) { } @@ -194,7 +203,40 @@ private: bool operator () (const event_listener_key input) const { - return (input.second == m_listener); + if (input.second == m_listener_sp) + return true; + else + return false; + } + + private: + const lldb::ListenerSP m_listener_sp; + }; + + class ListenerMatchesPointer + { + public: + ListenerMatchesPointer (const Listener *in_listener) : + m_listener (in_listener) + { + } + + ~ListenerMatchesPointer() = default; + + bool operator () (const event_listener_key input) const + { + if (input.second.get() == m_listener) + return true; + else + return false; + } + + bool operator () (const lldb::ListenerSP input) const + { + if (input.get() == m_listener) + return true; + else + return false; } private: @@ -237,6 +279,8 @@ private: //---------------------------------------------------------------------- class Broadcaster { +friend class Listener; +friend class Event; public: //------------------------------------------------------------------ /// Construct with a broadcaster with a name. @@ -245,7 +289,7 @@ public: /// A NULL terminated C string that contains the name of the /// broadcaster object. //------------------------------------------------------------------ - Broadcaster (BroadcasterManager *manager, const char *name); + Broadcaster (lldb::BroadcasterManagerSP manager_sp, const char *name); //------------------------------------------------------------------ /// Destructor. @@ -275,22 +319,37 @@ public: /// //------------------------------------------------------------------ void - BroadcastEvent (lldb::EventSP &event_sp); + BroadcastEvent (lldb::EventSP &event_sp) + { + m_broadcaster_sp->BroadcastEvent(event_sp); + } void - BroadcastEventIfUnique (lldb::EventSP &event_sp); + BroadcastEventIfUnique (lldb::EventSP &event_sp) + { + m_broadcaster_sp->BroadcastEventIfUnique(event_sp); + } void - BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr); + BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr) + { + m_broadcaster_sp->BroadcastEvent(event_type, event_data); + } void - BroadcastEventIfUnique(uint32_t event_type, EventData *event_data = nullptr); + BroadcastEventIfUnique(uint32_t event_type, EventData *event_data = nullptr) + { + m_broadcaster_sp->BroadcastEventIfUnique(event_type, event_data); + } void - Clear(); + Clear() + { + m_broadcaster_sp->Clear(); + } virtual void - AddInitialEventsToListener (Listener *listener, uint32_t requested_events); + AddInitialEventsToListener (lldb::ListenerSP listener_sp, uint32_t requested_events); //------------------------------------------------------------------ /// Listen for any events specified by \a event_mask. @@ -315,7 +374,10 @@ public: /// The actual event bits that were acquired by \a listener. //------------------------------------------------------------------ uint32_t - AddListener (Listener* listener, uint32_t event_mask); + AddListener (lldb::ListenerSP listener_sp, uint32_t event_mask) + { + return m_broadcaster_sp->AddListener(listener_sp, event_mask); + } //------------------------------------------------------------------ /// Get the NULL terminated C string name of this Broadcaster @@ -325,7 +387,10 @@ public: /// The NULL terminated C string name of this Broadcaster. //------------------------------------------------------------------ const ConstString & - GetBroadcasterName (); + GetBroadcasterName () + { + return m_broadcaster_name; + } //------------------------------------------------------------------ /// Get the event name(s) for one or more event bits. @@ -337,7 +402,10 @@ public: /// The NULL terminated C string name of this Broadcaster. //------------------------------------------------------------------ bool - GetEventNames (Stream &s, const uint32_t event_mask, bool prefix_with_broadcaster_name) const; + GetEventNames (Stream &s, const uint32_t event_mask, bool prefix_with_broadcaster_name) const + { + return m_broadcaster_sp->GetEventNames(s, event_mask, prefix_with_broadcaster_name); + } //------------------------------------------------------------------ /// Set the name for an event bit. @@ -352,20 +420,20 @@ public: void SetEventName (uint32_t event_mask, const char *name) { - m_event_names[event_mask] = name; + m_broadcaster_sp->SetEventName(event_mask, name); } const char * GetEventName (uint32_t event_mask) const { - const auto pos = m_event_names.find (event_mask); - if (pos != m_event_names.end()) - return pos->second.c_str(); - return nullptr; + return m_broadcaster_sp->GetEventName(event_mask); } bool - EventTypeHasListeners (uint32_t event_type); + EventTypeHasListeners (uint32_t event_type) + { + return m_broadcaster_sp->EventTypeHasListeners(event_type); + } //------------------------------------------------------------------ /// Removes a Listener from this broadcasters list and frees the @@ -386,7 +454,10 @@ public: /// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t) //------------------------------------------------------------------ bool - RemoveListener (Listener* listener, uint32_t event_mask = UINT32_MAX); + RemoveListener (lldb::ListenerSP listener_sp, uint32_t event_mask = UINT32_MAX) + { + return m_broadcaster_sp->RemoveListener(listener_sp, event_mask); + } //------------------------------------------------------------------ /// Provides a simple mechanism to temporarily redirect events from @@ -410,17 +481,26 @@ public: /// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t) //------------------------------------------------------------------ bool - HijackBroadcaster (Listener *listener, uint32_t event_mask = UINT32_MAX); + HijackBroadcaster (lldb::ListenerSP listener_sp, uint32_t event_mask = UINT32_MAX) + { + return m_broadcaster_sp->HijackBroadcaster(listener_sp, event_mask); + } bool - IsHijackedForEvent (uint32_t event_mask); + IsHijackedForEvent (uint32_t event_mask) + { + return m_broadcaster_sp->IsHijackedForEvent(event_mask); + } //------------------------------------------------------------------ /// Restore the state of the Broadcaster from a previous hijack attempt. /// //------------------------------------------------------------------ void - RestoreBroadcaster (); + RestoreBroadcaster () + { + m_broadcaster_sp->RestoreBroadcaster(); + } // This needs to be filled in if you are going to register the broadcaster with the broadcaster // manager and do broadcaster class matching. @@ -428,32 +508,145 @@ public: // with the BroadcasterManager, so that it is clearer how to add one. virtual ConstString &GetBroadcasterClass() const; - BroadcasterManager *GetManager(); + lldb::BroadcasterManagerSP GetManager(); protected: - void - PrivateBroadcastEvent (lldb::EventSP &event_sp, bool unique); + // BroadcasterImpl contains the actual Broadcaster implementation. The Broadcaster makes a BroadcasterImpl + // which lives as long as it does. The Listeners & the Events hold a weak pointer to the BroadcasterImpl, + // so that they can survive if a Broadcaster they were listening to is destroyed w/o their being able to + // unregister from it (which can happen if the Broadcasters & Listeners are being destroyed on separate threads + // simultaneously. + // The Broadcaster itself can't be shared out as a weak pointer, because some things that are broadcasters + // (e.g. the Target and the Process) are shared in their own right. + // + // For the most part, the Broadcaster functions dispatch to the BroadcasterImpl, and are documented in the + // public Broadcaster API above. + + + class BroadcasterImpl + { + friend class Listener; + friend class Broadcaster; + public: + BroadcasterImpl (Broadcaster &broadcaster); + + ~BroadcasterImpl() = default; + + void + BroadcastEvent (lldb::EventSP &event_sp); + + void + BroadcastEventIfUnique (lldb::EventSP &event_sp); + + void + BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr); + + void + BroadcastEventIfUnique(uint32_t event_type, EventData *event_data = nullptr); + void + Clear(); + + uint32_t + AddListener (lldb::ListenerSP listener_sp, uint32_t event_mask); + + const char * + GetBroadcasterName () const + { + return m_broadcaster.GetBroadcasterName().AsCString(); + } + + Broadcaster * + GetBroadcaster(); + + bool + GetEventNames (Stream &s, const uint32_t event_mask, bool prefix_with_broadcaster_name) const; + + void + SetEventName (uint32_t event_mask, const char *name) + { + m_event_names[event_mask] = name; + } + + const char * + GetEventName (uint32_t event_mask) const + { + const auto pos = m_event_names.find (event_mask); + if (pos != m_event_names.end()) + return pos->second.c_str(); + return nullptr; + } + + bool + EventTypeHasListeners (uint32_t event_type); + + bool + RemoveListener (lldb::ListenerSP listener_sp, uint32_t event_mask = UINT32_MAX); + + bool + HijackBroadcaster (lldb::ListenerSP listener_sp, uint32_t event_mask = UINT32_MAX); + + bool + IsHijackedForEvent (uint32_t event_mask); + + void + RestoreBroadcaster (); + + protected: + void + PrivateBroadcastEvent (lldb::EventSP &event_sp, bool unique); + + const char * + GetHijackingListenerName(); + + //------------------------------------------------------------------ + // + //------------------------------------------------------------------ + typedef std::vector< std::pair<lldb::ListenerSP,uint32_t> > collection; + typedef std::map<uint32_t, std::string> event_names_map; + + Broadcaster &m_broadcaster; ///< The broadcsater that this implements + event_names_map m_event_names; ///< Optionally define event names for readability and logging for each event bit + collection m_listeners; ///< A list of Listener / event_mask pairs that are listening to this broadcaster. + Mutex m_listeners_mutex; ///< A mutex that protects \a m_listeners. + std::vector<lldb::ListenerSP> m_hijacking_listeners; // A simple mechanism to intercept events from a broadcaster + std::vector<uint32_t> m_hijacking_masks; // At some point we may want to have a stack or Listener + // collections, but for now this is just for private hijacking. + + private: + //------------------------------------------------------------------ + // For Broadcaster only + //------------------------------------------------------------------ + DISALLOW_COPY_AND_ASSIGN (BroadcasterImpl); + }; + + typedef std::shared_ptr<BroadcasterImpl> BroadcasterImplSP; + typedef std::weak_ptr<BroadcasterImpl> BroadcasterImplWP; + + BroadcasterImplSP + GetBroadcasterImpl() + { + return m_broadcaster_sp; + } + + const char * + GetHijackingListenerName() + { + return m_broadcaster_sp->GetHijackingListenerName(); + } //------------------------------------------------------------------ // Classes that inherit from Broadcaster can see and modify these //------------------------------------------------------------------ - typedef std::vector< std::pair<Listener*,uint32_t> > collection; - typedef std::map<uint32_t, std::string> event_names_map; - // Prefix the name of our member variables with "m_broadcaster_" - // since this is a class that gets subclassed. - const ConstString m_broadcaster_name; ///< The name of this broadcaster object. - event_names_map m_event_names; ///< Optionally define event names for readability and logging for each event bit - collection m_listeners; ///< A list of Listener / event_mask pairs that are listening to this broadcaster. - Mutex m_listeners_mutex; ///< A mutex that protects \a m_listeners. - std::vector<Listener *> m_hijacking_listeners; // A simple mechanism to intercept events from a broadcaster - std::vector<uint32_t> m_hijacking_masks; // At some point we may want to have a stack or Listener - // collections, but for now this is just for private hijacking. - BroadcasterManager *m_manager; + private: //------------------------------------------------------------------ // For Broadcaster only //------------------------------------------------------------------ + BroadcasterImplSP m_broadcaster_sp; + lldb::BroadcasterManagerSP m_manager_sp; + const ConstString m_broadcaster_name; ///< The name of this broadcaster object. + DISALLOW_COPY_AND_ASSIGN (Broadcaster); }; diff --git a/lldb/include/lldb/Core/Debugger.h b/lldb/include/lldb/Core/Debugger.h index 4ca648ca296..6398008299d 100644 --- a/lldb/include/lldb/Core/Debugger.h +++ b/lldb/include/lldb/Core/Debugger.h @@ -53,8 +53,7 @@ namespace lldb_private { class Debugger : public std::enable_shared_from_this<Debugger>, public UserID, - public Properties, - public BroadcasterManager + public Properties { friend class SourceManager; // For GetSourceFileCache. @@ -159,10 +158,10 @@ public: return *m_command_interpreter_ap; } - Listener & + lldb::ListenerSP GetListener () { - return m_listener; + return m_listener_sp; } // This returns the Debugger's scratch source manager. It won't be able to look up files in debug @@ -392,6 +391,12 @@ public: Target *GetSelectedOrDummyTarget(bool prefer_dummy = false); Target *GetDummyTarget(); + lldb::BroadcasterManagerSP + GetBroadcasterManager() + { + return m_broadcaster_manager_sp; + } + protected: friend class CommandInterpreter; friend class REPL; @@ -446,15 +451,20 @@ protected: void InstanceInitialize (); - + lldb::StreamFileSP m_input_file_sp; lldb::StreamFileSP m_output_file_sp; lldb::StreamFileSP m_error_file_sp; + + lldb::BroadcasterManagerSP m_broadcaster_manager_sp; // The debugger acts as a broadcaster manager of last resort. + // It needs to get constructed before the target_list or any other + // member that might want to broadcast through the debugger. + TerminalState m_terminal_state; TargetList m_target_list; PlatformList m_platform_list; - Listener m_listener; + lldb::ListenerSP m_listener_sp; std::unique_ptr<SourceManager> m_source_manager_ap; // This is a scratch source manager that we return if we have no targets. SourceManager::SourceFileCache m_source_file_cache; // All the source managers for targets created in this debugger used this shared // source file cache. diff --git a/lldb/include/lldb/Core/Event.h b/lldb/include/lldb/Core/Event.h index e8867c0e7e7..05f8d7e0e1f 100644 --- a/lldb/include/lldb/Core/Event.h +++ b/lldb/include/lldb/Core/Event.h @@ -20,6 +20,7 @@ #include "lldb/lldb-private.h" #include "lldb/Core/ConstString.h" #include "lldb/Host/Predicate.h" +#include "lldb/Core/Broadcaster.h" namespace lldb_private { @@ -118,9 +119,9 @@ private: //---------------------------------------------------------------------- class Event { - friend class Broadcaster; friend class Listener; friend class EventData; + friend class Broadcaster::BroadcasterImpl; public: Event(Broadcaster *broadcaster, uint32_t event_type, EventData *data = nullptr); @@ -165,13 +166,21 @@ public: Broadcaster * GetBroadcaster () const { - return m_broadcaster; + Broadcaster::BroadcasterImplSP broadcaster_impl_sp = m_broadcaster_wp.lock(); + if (broadcaster_impl_sp) + return broadcaster_impl_sp->GetBroadcaster(); + else + return nullptr; } bool BroadcasterIs (Broadcaster *broadcaster) { - return broadcaster == m_broadcaster; + Broadcaster::BroadcasterImplSP broadcaster_impl_sp = m_broadcaster_wp.lock(); + if (broadcaster_impl_sp) + return broadcaster_impl_sp->GetBroadcaster() == broadcaster; + else + return false; } void @@ -194,10 +203,10 @@ private: void SetBroadcaster (Broadcaster *broadcaster) { - m_broadcaster = broadcaster; + m_broadcaster_wp = broadcaster->GetBroadcasterImpl(); } - Broadcaster * m_broadcaster; // The broadcaster that sent this event + Broadcaster::BroadcasterImplWP m_broadcaster_wp; // The broadcaster that sent this event uint32_t m_type; // The bit describing this event std::unique_ptr<EventData> m_data_ap; // User specific data for this event diff --git a/lldb/include/lldb/Core/Listener.h b/lldb/include/lldb/Core/Listener.h index b11c1644507..2e050c674ff 100644 --- a/lldb/include/lldb/Core/Listener.h +++ b/lldb/include/lldb/Core/Listener.h @@ -21,11 +21,13 @@ // Project includes #include "lldb/lldb-private.h" #include "lldb/Host/Predicate.h" +#include "lldb/Core/Broadcaster.h" #include "lldb/Core/Event.h" namespace lldb_private { -class Listener +class Listener : + public std::enable_shared_from_this<Listener> { public: typedef bool (*HandleBroadcastCallback) (lldb::EventSP &event_sp, void *baton); @@ -36,8 +38,16 @@ public: //------------------------------------------------------------------ // Constructors and Destructors //------------------------------------------------------------------ + // + // Listeners have to be constructed into shared pointers - at least if you want them to listen to + // Broadcasters, +protected: Listener (const char *name); +public: + static lldb::ListenerSP + MakeListener(const char *name); + ~Listener (); void @@ -53,11 +63,11 @@ public: } uint32_t - StartListeningForEventSpec (BroadcasterManager &manager, + StartListeningForEventSpec (lldb::BroadcasterManagerSP manager_sp, const BroadcastEventSpec &event_spec); bool - StopListeningForEventSpec (BroadcasterManager &manager, + StopListeningForEventSpec (lldb::BroadcasterManagerSP manager_sp, const BroadcastEventSpec &event_spec); uint32_t @@ -133,9 +143,11 @@ private: void *callback_user_data; }; - typedef std::multimap<Broadcaster*, BroadcasterInfo> broadcaster_collection; + typedef std::multimap<Broadcaster::BroadcasterImplWP, + BroadcasterInfo, + std::owner_less<Broadcaster::BroadcasterImplWP>> broadcaster_collection; typedef std::list<lldb::EventSP> event_collection; - typedef std::vector<BroadcasterManager *> broadcaster_manager_collection; + typedef std::vector<lldb::BroadcasterManagerWP> broadcaster_manager_collection; bool FindNextEventInternal(Broadcaster *broadcaster, // nullptr for any broadcaster @@ -172,7 +184,7 @@ private: BroadcasterWillDestruct (Broadcaster *); void - BroadcasterManagerWillDestruct (BroadcasterManager *manager); + BroadcasterManagerWillDestruct (lldb::BroadcasterManagerSP manager_sp); // broadcaster_collection::iterator diff --git a/lldb/include/lldb/Target/Process.h b/lldb/include/lldb/Target/Process.h index 09e6c2755c1..e6e12601a76 100644 --- a/lldb/include/lldb/Target/Process.h +++ b/lldb/include/lldb/Target/Process.h @@ -30,6 +30,7 @@ #include "lldb/Core/Communication.h" #include "lldb/Core/Error.h" #include "lldb/Core/Event.h" +#include "lldb/Core/Listener.h" #include "lldb/Core/LoadedModuleInfoList.h" #include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/PluginInterface.h" @@ -400,7 +401,7 @@ public: m_listener_sp = listener_sp; } - Listener & + lldb::ListenerSP GetListenerForProcess (Debugger &debugger); protected: @@ -939,13 +940,13 @@ public: /// Construct with a shared pointer to a target, and the Process listener. /// Uses the Host UnixSignalsSP by default. //------------------------------------------------------------------ - Process(lldb::TargetSP target_sp, Listener &listener); + Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp); //------------------------------------------------------------------ /// Construct with a shared pointer to a target, the Process listener, /// and the appropriate UnixSignalsSP for the process. //------------------------------------------------------------------ - Process(lldb::TargetSP target_sp, Listener &listener, const lldb::UnixSignalsSP &unix_signals_sp); + Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const lldb::UnixSignalsSP &unix_signals_sp); //------------------------------------------------------------------ /// Destructor. @@ -985,7 +986,7 @@ public: static lldb::ProcessSP FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, - Listener &listener, + lldb::ListenerSP listener_sp, const FileSpec *crash_file_path); //------------------------------------------------------------------ @@ -2851,7 +2852,7 @@ public: WaitForProcessToStop(const TimeValue *timeout, lldb::EventSP *event_sp_ptr = nullptr, bool wait_always = true, - Listener *hijack_listener = nullptr, + lldb::ListenerSP hijack_listener = lldb::ListenerSP(), Stream *stream = nullptr, bool use_run_lock = true); @@ -2877,7 +2878,7 @@ public: lldb::StateType WaitForStateChangedEvents(const TimeValue *timeout, lldb::EventSP &event_sp, - Listener *hijack_listener); // Pass nullptr to use builtin listener + lldb::ListenerSP hijack_listener); // Pass an empty ListenerSP to use builtin listener //-------------------------------------------------------------------------------------- /// Centralize the code that handles and prints descriptions for process state changes. @@ -2908,10 +2909,10 @@ public: ProcessEventHijacker { public: - ProcessEventHijacker (Process &process, Listener *listener) : + ProcessEventHijacker (Process &process, lldb::ListenerSP listener_sp) : m_process (process) { - m_process.HijackProcessEvents (listener); + m_process.HijackProcessEvents (listener_sp); } ~ProcessEventHijacker () @@ -2940,7 +2941,7 @@ public: /// \b false otherwise. //------------------------------------------------------------------ bool - HijackProcessEvents (Listener *listener); + HijackProcessEvents (lldb::ListenerSP listener_sp); //------------------------------------------------------------------ /// Restores the process event broadcasting to its normal state. @@ -3343,7 +3344,7 @@ protected: ThreadSafeValue<lldb::StateType> m_private_state; // The actual state of our process Broadcaster m_private_state_broadcaster; // This broadcaster feeds state changed events into the private state thread's listener. Broadcaster m_private_state_control_broadcaster; // This is the control broadcaster, used to pause, resume & stop the private state thread. - Listener m_private_state_listener; // This is the listener for the private state thread. + lldb::ListenerSP m_private_state_listener_sp; // This is the listener for the private state thread. Predicate<bool> m_private_state_control_wait; /// This Predicate is used to signal that a control operation is complete. HostThread m_private_state_thread; ///< Thread ID for the thread that watches internal state events ProcessModID m_mod_id; ///< Tracks the state of the process over stops and other alterations. @@ -3363,7 +3364,7 @@ protected: uint32_t m_queue_list_stop_id; ///< The natural stop id when queue list was last fetched std::vector<Notifications> m_notifications; ///< The list of notifications that this process can deliver. std::vector<lldb::addr_t> m_image_tokens; - Listener &m_listener; + lldb::ListenerSP m_listener_sp; ///< Shared pointer to the listener used for public events. Can not be empty. BreakpointSiteList m_breakpoint_site_list; ///< This is the list of breakpoint locations we intend to insert in the target. lldb::DynamicLoaderUP m_dyld_ap; lldb::JITLoaderListUP m_jit_loaders_ap; diff --git a/lldb/include/lldb/Target/ProcessLaunchInfo.h b/lldb/include/lldb/Target/ProcessLaunchInfo.h index 92a3ed40736..eb5a66dfdb3 100644 --- a/lldb/include/lldb/Target/ProcessLaunchInfo.h +++ b/lldb/include/lldb/Target/ProcessLaunchInfo.h @@ -196,7 +196,7 @@ namespace lldb_private m_listener_sp = listener_sp; } - Listener & + lldb::ListenerSP GetListenerForProcess (Debugger &debugger); lldb::ListenerSP diff --git a/lldb/include/lldb/Target/Target.h b/lldb/include/lldb/Target/Target.h index 5932dda4619..dcc594089eb 100644 --- a/lldb/include/lldb/Target/Target.h +++ b/lldb/include/lldb/Target/Target.h @@ -719,7 +719,7 @@ public: Dump (Stream *s, lldb::DescriptionLevel description_level); const lldb::ProcessSP & - CreateProcess (Listener &listener, + CreateProcess (lldb::ListenerSP listener, const char *plugin_name, const FileSpec *crash_file); diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h index 516f31911c2..f67dab12614 100644 --- a/lldb/include/lldb/lldb-forward.h +++ b/lldb/include/lldb/lldb-forward.h @@ -310,6 +310,8 @@ namespace lldb { typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP; typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP; typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP; + typedef std::shared_ptr<lldb_private::BroadcasterManager> BroadcasterManagerSP; + typedef std::weak_ptr<lldb_private::BroadcasterManager> BroadcasterManagerWP; typedef std::unique_ptr<lldb_private::ClangASTContext> ClangASTContextUP; typedef std::shared_ptr<lldb_private::ClangASTImporter> ClangASTImporterSP; typedef std::unique_ptr<lldb_private::ClangModulesDeclVendor> ClangModulesDeclVendorUP; diff --git a/lldb/include/lldb/lldb-private-interfaces.h b/lldb/include/lldb/lldb-private-interfaces.h index 6bc8dadaebf..8775ce6bc56 100644 --- a/lldb/include/lldb/lldb-private-interfaces.h +++ b/lldb/include/lldb/lldb-private-interfaces.h @@ -35,7 +35,7 @@ namespace lldb_private typedef lldb::CommandObjectSP (*LanguageRuntimeGetCommandObject) (CommandInterpreter& interpreter); typedef SystemRuntime *(*SystemRuntimeCreateInstance) (Process *process); typedef lldb::PlatformSP (*PlatformCreateInstance) (bool force, const ArchSpec *arch); - typedef lldb::ProcessSP (*ProcessCreateInstance) (lldb::TargetSP target_sp, Listener &listener, const FileSpec *crash_file_path); + typedef lldb::ProcessSP (*ProcessCreateInstance) (lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file_path); typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(CommandInterpreter &interpreter); typedef SymbolFile* (*SymbolFileCreateInstance) (ObjectFile* obj_file); typedef SymbolVendor* (*SymbolVendorCreateInstance) (const lldb::ModuleSP &module_sp, lldb_private::Stream *feedback_strm); // Module can be NULL for default system symbol vendor diff --git a/lldb/packages/Python/lldbsuite/test/api/listeners/Makefile b/lldb/packages/Python/lldbsuite/test/api/listeners/Makefile new file mode 100644 index 00000000000..fbedeab4cb9 --- /dev/null +++ b/lldb/packages/Python/lldbsuite/test/api/listeners/Makefile @@ -0,0 +1,6 @@ +LEVEL = ../../make + +C_SOURCES := main.c + +include $(LEVEL)/Makefile.rules + diff --git a/lldb/packages/Python/lldbsuite/test/api/listeners/TestListener.py b/lldb/packages/Python/lldbsuite/test/api/listeners/TestListener.py new file mode 100644 index 00000000000..bd8c204e78c --- /dev/null +++ b/lldb/packages/Python/lldbsuite/test/api/listeners/TestListener.py @@ -0,0 +1,55 @@ +""" +Test that we can listen to modules loaded events. +""" + +from __future__ import print_function + +import copy +import os +import time + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + +import six + +class ListenToModuleLoadedEvents (TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + self.build() + + def test_receiving_breakpoint_added (self): + """Test that we get breakpoint added events, waiting on event classes on the debugger""" + + my_listener = lldb.SBListener("test_listener") + + my_listener.StartListeningForEventClass(self.dbg, lldb.SBTarget.GetBroadcasterClassName(), lldb.SBTarget.eBroadcastBitBreakpointChanged) + + exe = os.path.join (os.getcwd(), "a.out") + + target = self.dbg.CreateTarget(exe) + + bkpt = target.BreakpointCreateByName("main") + + event = lldb.SBEvent() + my_listener.WaitForEvent(1, event) + + self.assertTrue(event.IsValid(), "Got a valid event.") + self.assertTrue(lldb.SBBreakpoint.EventIsBreakpointEvent(event), "It is a breakpoint event.") + self.assertTrue(lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event) == lldb.eBreakpointEventTypeAdded, "It is a breakpoint added event.") + self.assertTrue(bkpt == lldb.SBBreakpoint.GetBreakpointFromEvent(event), "It is our breakpoint.") + + # Now make sure if we stop listening for events we don't get them: + + my_listener.StopListeningForEventClass(self.dbg, lldb.SBTarget.GetBroadcasterClassName(), lldb.SBTarget.eBroadcastBitBreakpointChanged) + my_listener.StopListeningForEvents(target.GetBroadcaster(), lldb.SBTarget.eBroadcastBitBreakpointChanged) + + bkpt2 = target.BreakpointCreateByName("main") + my_listener.WaitForEvent(1, event) + self.assertTrue(not event.IsValid(), "We don't get events we aren't listening to.") diff --git a/lldb/packages/Python/lldbsuite/test/api/listeners/main.c b/lldb/packages/Python/lldbsuite/test/api/listeners/main.c new file mode 100644 index 00000000000..f930e511915 --- /dev/null +++ b/lldb/packages/Python/lldbsuite/test/api/listeners/main.c @@ -0,0 +1,7 @@ +#include <stdio.h> + +int +main() +{ + printf ("Hello there.\n"); +} diff --git a/lldb/source/API/SBBroadcaster.cpp b/lldb/source/API/SBBroadcaster.cpp index 73eac5183f8..4b751adc295 100644 --- a/lldb/source/API/SBBroadcaster.cpp +++ b/lldb/source/API/SBBroadcaster.cpp @@ -117,14 +117,14 @@ SBBroadcaster::AddInitialEventsToListener (const SBListener &listener, uint32_t static_cast<void*>(m_opaque_ptr), static_cast<void*>(listener.get()), requested_events); if (m_opaque_ptr) - m_opaque_ptr->AddInitialEventsToListener (listener.get(), requested_events); + m_opaque_ptr->AddInitialEventsToListener (listener.m_opaque_sp, requested_events); } uint32_t SBBroadcaster::AddListener (const SBListener &listener, uint32_t event_mask) { if (m_opaque_ptr) - return m_opaque_ptr->AddListener (listener.get(), event_mask); + return m_opaque_ptr->AddListener (listener.m_opaque_sp, event_mask); return 0; } @@ -148,7 +148,7 @@ bool SBBroadcaster::RemoveListener (const SBListener &listener, uint32_t event_mask) { if (m_opaque_ptr) - return m_opaque_ptr->RemoveListener (listener.get(), event_mask); + return m_opaque_ptr->RemoveListener (listener.m_opaque_sp, event_mask); return false; } diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp index 1645294b5a3..f03262e2454 100644 --- a/lldb/source/API/SBDebugger.cpp +++ b/lldb/source/API/SBDebugger.cpp @@ -432,8 +432,8 @@ SBDebugger::HandleCommand (const char *command) if (process_sp) { EventSP event_sp; - Listener &lldb_listener = m_opaque_sp->GetListener(); - while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp)) + ListenerSP lldb_listener_sp = m_opaque_sp->GetListener(); + while (lldb_listener_sp->GetNextEventForBroadcaster (process_sp.get(), event_sp)) { SBEvent event(event_sp); HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); @@ -450,7 +450,7 @@ SBDebugger::GetListener () SBListener sb_listener; if (m_opaque_sp) - sb_listener.reset(&m_opaque_sp->GetListener(), false); + sb_listener.reset(m_opaque_sp->GetListener()); if (log) log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", diff --git a/lldb/source/API/SBListener.cpp b/lldb/source/API/SBListener.cpp index 643c82d70f7..8e63de0b769 100644 --- a/lldb/source/API/SBListener.cpp +++ b/lldb/source/API/SBListener.cpp @@ -26,27 +26,25 @@ using namespace lldb_private; SBListener::SBListener () : m_opaque_sp (), - m_opaque_ptr (NULL) + m_unused_ptr (NULL) { } SBListener::SBListener (const char *name) : - m_opaque_sp (new Listener (name)), - m_opaque_ptr (NULL) + m_opaque_sp (Listener::MakeListener(name)), + m_unused_ptr (nullptr) { - m_opaque_ptr = m_opaque_sp.get(); - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) log->Printf ("SBListener::SBListener (name=\"%s\") => SBListener(%p)", - name, static_cast<void*>(m_opaque_ptr)); + name, static_cast<void*>(m_opaque_sp.get())); } SBListener::SBListener (const SBListener &rhs) : m_opaque_sp (rhs.m_opaque_sp), - m_opaque_ptr (rhs.m_opaque_ptr) + m_unused_ptr (nullptr) { } @@ -56,20 +54,14 @@ SBListener::operator = (const lldb::SBListener &rhs) if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; - m_opaque_ptr = rhs.m_opaque_ptr; + m_unused_ptr = nullptr; } return *this; } -SBListener::SBListener (Listener &listener) : - m_opaque_sp (), - m_opaque_ptr (&listener) -{ -} - SBListener::SBListener (const lldb::ListenerSP &listener_sp) : m_opaque_sp (listener_sp), - m_opaque_ptr (listener_sp.get()) + m_unused_ptr (nullptr) { } @@ -80,7 +72,7 @@ SBListener::~SBListener () bool SBListener::IsValid() const { - return m_opaque_ptr != NULL; + return m_opaque_sp != nullptr; } void @@ -88,14 +80,14 @@ SBListener::AddEvent (const SBEvent &event) { EventSP &event_sp = event.GetSP (); if (event_sp) - m_opaque_ptr->AddEvent (event_sp); + m_opaque_sp->AddEvent (event_sp); } void SBListener::Clear () { - if (m_opaque_ptr) - m_opaque_ptr->Clear (); + if (m_opaque_sp) + m_opaque_sp->Clear (); } uint32_t @@ -103,13 +95,13 @@ SBListener::StartListeningForEventClass (SBDebugger &debugger, const char *broadcaster_class, uint32_t event_mask) { - if (m_opaque_ptr) + if (m_opaque_sp) { Debugger *lldb_debugger = debugger.get(); if (!lldb_debugger) return 0; BroadcastEventSpec event_spec (ConstString (broadcaster_class), event_mask); - return m_opaque_ptr->StartListeningForEventSpec (*lldb_debugger, event_spec); + return m_opaque_sp->StartListeningForEventSpec (lldb_debugger->GetBroadcasterManager(), event_spec); } else return 0; @@ -120,13 +112,13 @@ SBListener::StopListeningForEventClass (SBDebugger &debugger, const char *broadcaster_class, uint32_t event_mask) { - if (m_opaque_ptr) + if (m_opaque_sp) { Debugger *lldb_debugger = debugger.get(); if (!lldb_debugger) return false; BroadcastEventSpec event_spec (ConstString (broadcaster_class), event_mask); - return m_opaque_ptr->StopListeningForEventSpec (*lldb_debugger, event_spec); + return m_opaque_sp->StopListeningForEventSpec (lldb_debugger->GetBroadcasterManager(), event_spec); } else return false; @@ -136,9 +128,9 @@ uint32_t SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask) { uint32_t acquired_event_mask = 0; - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { - acquired_event_mask = m_opaque_ptr->StartListeningForEvents (broadcaster.get(), event_mask); + acquired_event_mask = m_opaque_sp->StartListeningForEvents (broadcaster.get(), event_mask); } Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API); @@ -153,7 +145,7 @@ SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t const bool got_requested_names = lldb_broadcaster->GetEventNames (sstr_requested, event_mask, false); const bool got_acquired_names = lldb_broadcaster->GetEventNames (sstr_acquired, acquired_event_mask, false); log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p): %s, event_mask=0x%8.8x%s%s%s) => 0x%8.8x%s%s%s", - static_cast<void*>(m_opaque_ptr), + static_cast<void*>(m_opaque_sp.get()), static_cast<void*>(lldb_broadcaster), lldb_broadcaster->GetBroadcasterName().GetCString(), event_mask, @@ -168,7 +160,7 @@ SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t else { log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p), event_mask=0x%8.8x) => 0x%8.8x", - static_cast<void*>(m_opaque_ptr), + static_cast<void*>(m_opaque_sp.get()), static_cast<void*>(lldb_broadcaster), event_mask, acquired_event_mask); } @@ -180,9 +172,9 @@ SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t bool SBListener::StopListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask) { - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { - return m_opaque_ptr->StopListeningForEvents (broadcaster.get(), event_mask); + return m_opaque_sp->StopListeningForEvents (broadcaster.get(), event_mask); } return false; } @@ -196,19 +188,19 @@ SBListener::WaitForEvent (uint32_t timeout_secs, SBEvent &event) if (timeout_secs == UINT32_MAX) { log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p))...", - static_cast<void*>(m_opaque_ptr), + static_cast<void*>(m_opaque_sp.get()), static_cast<void*>(event.get())); } else { log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p))...", - static_cast<void*>(m_opaque_ptr), timeout_secs, + static_cast<void*>(m_opaque_sp.get()), timeout_secs, static_cast<void*>(event.get())); } } bool success = false; - if (m_opaque_ptr) + if (m_opaque_sp) { TimeValue time_value; if (timeout_secs != UINT32_MAX) @@ -218,7 +210,7 @@ SBListener::WaitForEvent (uint32_t timeout_secs, SBEvent &event) time_value.OffsetWithSeconds (timeout_secs); } EventSP event_sp; - if (m_opaque_ptr->WaitForEvent (time_value.IsValid() ? &time_value : NULL, event_sp)) + if (m_opaque_sp->WaitForEvent (time_value.IsValid() ? &time_value : NULL, event_sp)) { event.reset (event_sp); success = true; @@ -230,13 +222,13 @@ SBListener::WaitForEvent (uint32_t timeout_secs, SBEvent &event) if (timeout_secs == UINT32_MAX) { log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p)) => %i", - static_cast<void*>(m_opaque_ptr), + static_cast<void*>(m_opaque_sp.get()), static_cast<void*>(event.get()), success); } else { log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p)) => %i", - static_cast<void*>(m_opaque_ptr), timeout_secs, + static_cast<void*>(m_opaque_sp.get()), timeout_secs, static_cast<void*>(event.get()), success); } } @@ -253,7 +245,7 @@ SBListener::WaitForEventForBroadcaster SBEvent &event ) { - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { TimeValue time_value; if (num_seconds != UINT32_MAX) @@ -262,7 +254,7 @@ SBListener::WaitForEventForBroadcaster time_value.OffsetWithSeconds (num_seconds); } EventSP event_sp; - if (m_opaque_ptr->WaitForEventForBroadcaster (time_value.IsValid() ? &time_value : NULL, + if (m_opaque_sp->WaitForEventForBroadcaster (time_value.IsValid() ? &time_value : NULL, broadcaster.get(), event_sp)) { @@ -284,7 +276,7 @@ SBListener::WaitForEventForBroadcasterWithType SBEvent &event ) { - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { TimeValue time_value; if (num_seconds != UINT32_MAX) @@ -293,7 +285,7 @@ SBListener::WaitForEventForBroadcasterWithType time_value.OffsetWithSeconds (num_seconds); } EventSP event_sp; - if (m_opaque_ptr->WaitForEventForBroadcasterWithType (time_value.IsValid() ? &time_value : NULL, + if (m_opaque_sp->WaitForEventForBroadcasterWithType (time_value.IsValid() ? &time_value : NULL, broadcaster.get(), event_type_mask, event_sp)) @@ -309,9 +301,9 @@ SBListener::WaitForEventForBroadcasterWithType bool SBListener::PeekAtNextEvent (SBEvent &event) { - if (m_opaque_ptr) + if (m_opaque_sp) { - event.reset (m_opaque_ptr->PeekAtNextEvent ()); + event.reset (m_opaque_sp->PeekAtNextEvent ()); return event.IsValid(); } event.reset (NULL); @@ -321,9 +313,9 @@ SBListener::PeekAtNextEvent (SBEvent &event) bool SBListener::PeekAtNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event) { - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { - event.reset (m_opaque_ptr->PeekAtNextEventForBroadcaster (broadcaster.get())); + event.reset (m_opaque_sp->PeekAtNextEventForBroadcaster (broadcaster.get())); return event.IsValid(); } event.reset (NULL); @@ -334,9 +326,9 @@ bool SBListener::PeekAtNextEventForBroadcasterWithType (const SBBroadcaster &broadcaster, uint32_t event_type_mask, SBEvent &event) { - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { - event.reset(m_opaque_ptr->PeekAtNextEventForBroadcasterWithType (broadcaster.get(), event_type_mask)); + event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType (broadcaster.get(), event_type_mask)); return event.IsValid(); } event.reset (NULL); @@ -346,10 +338,10 @@ SBListener::PeekAtNextEventForBroadcasterWithType (const SBBroadcaster &broadcas bool SBListener::GetNextEvent (SBEvent &event) { - if (m_opaque_ptr) + if (m_opaque_sp) { EventSP event_sp; - if (m_opaque_ptr->GetNextEvent (event_sp)) + if (m_opaque_sp->GetNextEvent (event_sp)) { event.reset (event_sp); return true; @@ -362,10 +354,10 @@ SBListener::GetNextEvent (SBEvent &event) bool SBListener::GetNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event) { - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { EventSP event_sp; - if (m_opaque_ptr->GetNextEventForBroadcaster (broadcaster.get(), event_sp)) + if (m_opaque_sp->GetNextEventForBroadcaster (broadcaster.get(), event_sp)) { event.reset (event_sp); return true; @@ -383,10 +375,10 @@ SBListener::GetNextEventForBroadcasterWithType SBEvent &event ) { - if (m_opaque_ptr && broadcaster.IsValid()) + if (m_opaque_sp && broadcaster.IsValid()) { EventSP event_sp; - if (m_opaque_ptr->GetNextEventForBroadcasterWithType (broadcaster.get(), + if (m_opaque_sp->GetNextEventForBroadcasterWithType (broadcaster.get(), event_type_mask, event_sp)) { @@ -401,49 +393,28 @@ SBListener::GetNextEventForBroadcasterWithType bool SBListener::HandleBroadcastEvent (const SBEvent &event) { - if (m_opaque_ptr) - return m_opaque_ptr->HandleBroadcastEvent (event.GetSP()); + if (m_opaque_sp) + return m_opaque_sp->HandleBroadcastEvent (event.GetSP()); return false; } Listener * SBListener::operator->() const { - return m_opaque_ptr; + return m_opaque_sp.get(); } Listener * SBListener::get() const { - return m_opaque_ptr; + return m_opaque_sp.get(); } void -SBListener::reset(Listener *listener, bool owns) -{ - if (owns) - m_opaque_sp.reset (listener); - else - m_opaque_sp.reset (); - m_opaque_ptr = listener; -} - -Listener & -SBListener::ref() const -{ - return *m_opaque_ptr; -} - -Listener & -SBListener::operator *() -{ - return *m_opaque_ptr; -} - -const Listener & -SBListener::operator *() const +SBListener::reset(ListenerSP listener_sp) { - return *m_opaque_ptr; + m_opaque_sp = listener_sp; + m_unused_ptr = nullptr; } diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp index 67c3e429c25..8dc5bb14cf5 100644 --- a/lldb/source/API/SBTarget.cpp +++ b/lldb/source/API/SBTarget.cpp @@ -623,7 +623,7 @@ SBTarget::ConnectRemote { Mutex::Locker api_locker (target_sp->GetAPIMutex()); if (listener.IsValid()) - process_sp = target_sp->CreateProcess (listener.ref(), plugin_name, NULL); + process_sp = target_sp->CreateProcess (listener.m_opaque_sp, plugin_name, NULL); else process_sp = target_sp->CreateProcess (target_sp->GetDebugger().GetListener(), plugin_name, NULL); diff --git a/lldb/source/Core/Broadcaster.cpp b/lldb/source/Core/Broadcaster.cpp index 84a42ae3d7e..6494e3d85bc 100644 --- a/lldb/source/Core/Broadcaster.cpp +++ b/lldb/source/Core/Broadcaster.cpp @@ -15,23 +15,31 @@ // Project includes #include "lldb/Core/Log.h" #include "lldb/Core/Event.h" +#include "lldb/Core/Listener.h" #include "lldb/Core/StreamString.h" using namespace lldb; using namespace lldb_private; -Broadcaster::Broadcaster (BroadcasterManager *manager, const char *name) : - m_broadcaster_name (name), +Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name) : + m_broadcaster_sp(new BroadcasterImpl(*this)), + m_manager_sp(manager_sp), + m_broadcaster_name(name) + +{ +} + +Broadcaster::BroadcasterImpl::BroadcasterImpl (Broadcaster &broadcaster) : + m_broadcaster(broadcaster), m_listeners (), m_listeners_mutex (Mutex::eMutexTypeRecursive), m_hijacking_listeners(), - m_hijacking_masks(), - m_manager (manager) + m_hijacking_masks() { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); if (log) log->Printf ("%p Broadcaster::Broadcaster(\"%s\")", - static_cast<void*>(this), m_broadcaster_name.AsCString()); + static_cast<void*>(this), m_broadcaster.GetBroadcasterName().AsCString()); } Broadcaster::~Broadcaster() @@ -47,14 +55,14 @@ Broadcaster::~Broadcaster() void Broadcaster::CheckInWithManager () { - if (m_manager != nullptr) + if (m_manager_sp) { - m_manager->SignUpListenersForBroadcaster(*this); + m_manager_sp->SignUpListenersForBroadcaster(*this); } } void -Broadcaster::Clear() +Broadcaster::BroadcasterImpl::Clear() { Mutex::Locker listeners_locker(m_listeners_mutex); @@ -64,19 +72,19 @@ Broadcaster::Clear() collection::iterator pos, end = m_listeners.end(); for (pos = m_listeners.begin(); pos != end; ++pos) - pos->first->BroadcasterWillDestruct (this); + pos->first->BroadcasterWillDestruct (&m_broadcaster); m_listeners.clear(); } -const ConstString & -Broadcaster::GetBroadcasterName () +Broadcaster * +Broadcaster::BroadcasterImpl::GetBroadcaster() { - return m_broadcaster_name; + return &m_broadcaster; } bool -Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const +Broadcaster::BroadcasterImpl::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const { uint32_t num_names_added = 0; if (event_mask && !m_event_names.empty()) @@ -94,7 +102,7 @@ Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_bro if (prefix_with_broadcaster_name) { - s.PutCString (m_broadcaster_name.GetCString()); + s.PutCString (GetBroadcasterName()); s.PutChar('.'); } s.PutCString(pos->second.c_str()); @@ -107,14 +115,14 @@ Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_bro } void -Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events) +Broadcaster::AddInitialEventsToListener (lldb::ListenerSP listener_sp, uint32_t requested_events) { } uint32_t -Broadcaster::AddListener (Listener* listener, uint32_t event_mask) +Broadcaster::BroadcasterImpl::AddListener (lldb::ListenerSP listener_sp, uint32_t event_mask) { - if (listener == nullptr) + if (!listener_sp) return 0; Mutex::Locker locker(m_listeners_mutex); @@ -125,7 +133,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask) uint32_t taken_event_types = 0; for (pos = m_listeners.begin(); pos != end; ++pos) { - if (pos->first == listener) + if (pos->first == listener_sp) existing_pos = pos; // For now don't descriminate on who gets what // FIXME: Implement "unique listener for this bit" mask @@ -142,7 +150,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask) if (existing_pos == end) { // Grant a new listener the available event bits - m_listeners.push_back(std::make_pair(listener, available_event_types)); + m_listeners.push_back(std::make_pair(listener_sp, available_event_types)); } else { @@ -153,7 +161,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask) // Individual broadcasters decide whether they have outstanding data when a // listener attaches, and insert it into the listener with this method. - AddInitialEventsToListener (listener, available_event_types); + m_broadcaster.AddInitialEventsToListener (listener_sp, available_event_types); } // Return the event bits that were granted to the listener @@ -161,7 +169,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask) } bool -Broadcaster::EventTypeHasListeners (uint32_t event_type) +Broadcaster::BroadcasterImpl::EventTypeHasListeners (uint32_t event_type) { Mutex::Locker locker (m_listeners_mutex); @@ -181,14 +189,14 @@ Broadcaster::EventTypeHasListeners (uint32_t event_type) } bool -Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask) +Broadcaster::BroadcasterImpl::RemoveListener (lldb::ListenerSP listener_sp, uint32_t event_mask) { Mutex::Locker locker(m_listeners_mutex); collection::iterator pos, end = m_listeners.end(); // See if we already have this listener, and if so, update its mask for (pos = m_listeners.begin(); pos != end; ++pos) { - if (pos->first == listener) + if (pos->first == listener_sp) { // Relinquish all event bits in "event_mask" pos->second &= ~event_mask; @@ -202,38 +210,39 @@ Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask) } void -Broadcaster::BroadcastEvent (EventSP &event_sp) +Broadcaster::BroadcasterImpl::BroadcastEvent (EventSP &event_sp) { return PrivateBroadcastEvent (event_sp, false); } void -Broadcaster::BroadcastEventIfUnique (EventSP &event_sp) +Broadcaster::BroadcasterImpl::BroadcastEventIfUnique (EventSP &event_sp) { return PrivateBroadcastEvent (event_sp, true); } void -Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique) +Broadcaster::BroadcasterImpl::PrivateBroadcastEvent (EventSP &event_sp, bool unique) { // Can't add a nullptr event... if (!event_sp) return; // Update the broadcaster on this event - event_sp->SetBroadcaster (this); + event_sp->SetBroadcaster (&m_broadcaster); const uint32_t event_type = event_sp->GetType(); Mutex::Locker event_types_locker(m_listeners_mutex); - Listener *hijacking_listener = nullptr; + ListenerSP hijacking_listener_sp; + if (!m_hijacking_listeners.empty()) { assert (!m_hijacking_masks.empty()); - hijacking_listener = m_hijacking_listeners.back(); + hijacking_listener_sp = m_hijacking_listeners.back(); if ((event_type & m_hijacking_masks.back()) == 0) - hijacking_listener = nullptr; + hijacking_listener_sp.reset(); } Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS)); @@ -242,16 +251,16 @@ Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique) StreamString event_description; event_sp->Dump (&event_description); log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p", - static_cast<void*>(this), m_broadcaster_name.AsCString(""), + static_cast<void*>(this), GetBroadcasterName(), event_description.GetData(), unique, - static_cast<void*>(hijacking_listener)); + static_cast<void*>(hijacking_listener_sp.get())); } - if (hijacking_listener) + if (hijacking_listener_sp) { - if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type)) + if (unique && hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType (&m_broadcaster, event_type)) return; - hijacking_listener->AddEvent (event_sp); + hijacking_listener_sp->AddEvent (event_sp); } else { @@ -264,7 +273,7 @@ Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique) // put the new event on its event queue. if (event_type & pos->second) { - if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type)) + if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (&m_broadcaster, event_type)) continue; pos->first->AddEvent (event_sp); } @@ -273,36 +282,36 @@ Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique) } void -Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data) +Broadcaster::BroadcasterImpl::BroadcastEvent (uint32_t event_type, EventData *event_data) { EventSP event_sp (new Event (event_type, event_data)); PrivateBroadcastEvent (event_sp, false); } void -Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data) +Broadcaster::BroadcasterImpl::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data) { EventSP event_sp (new Event (event_type, event_data)); PrivateBroadcastEvent (event_sp, true); } bool -Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask) +Broadcaster::BroadcasterImpl::HijackBroadcaster (ListenerSP listener_sp, uint32_t event_mask) { Mutex::Locker event_types_locker(m_listeners_mutex); Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS)); if (log) log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)", - static_cast<void*>(this), m_broadcaster_name.AsCString(""), - listener->m_name.c_str(), static_cast<void*>(listener)); - m_hijacking_listeners.push_back(listener); + static_cast<void*>(this), GetBroadcasterName(), + listener_sp->m_name.c_str(), static_cast<void*>(listener_sp.get())); + m_hijacking_listeners.push_back(listener_sp); m_hijacking_masks.push_back(event_mask); return true; } bool -Broadcaster::IsHijackedForEvent (uint32_t event_mask) +Broadcaster::BroadcasterImpl::IsHijackedForEvent (uint32_t event_mask) { Mutex::Locker event_types_locker(m_listeners_mutex); @@ -311,8 +320,21 @@ Broadcaster::IsHijackedForEvent (uint32_t event_mask) return false; } +const char * +Broadcaster::BroadcasterImpl::GetHijackingListenerName() +{ + if (m_hijacking_listeners.size()) + { + return m_hijacking_listeners.back()->GetName(); + } + else + { + return nullptr; + } +} + void -Broadcaster::RestoreBroadcaster () +Broadcaster::BroadcasterImpl::RestoreBroadcaster () { Mutex::Locker event_types_locker(m_listeners_mutex); @@ -321,11 +343,11 @@ Broadcaster::RestoreBroadcaster () Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS)); if (log) { - Listener *listener = m_hijacking_listeners.back(); + ListenerSP listener_sp = m_hijacking_listeners.back(); log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)", static_cast<void*>(this), - m_broadcaster_name.AsCString(""), - listener->m_name.c_str(), static_cast<void*>(listener)); + GetBroadcasterName(), + listener_sp->m_name.c_str(), static_cast<void*>(listener_sp.get())); } m_hijacking_listeners.pop_back(); } @@ -363,8 +385,14 @@ BroadcasterManager::BroadcasterManager() : { } +lldb::BroadcasterManagerSP +BroadcasterManager::MakeBroadcasterManager() +{ + return BroadcasterManagerSP(new BroadcasterManager()); +} + uint32_t -BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec) +BroadcasterManager::RegisterListenerForEvents (ListenerSP listener_sp, BroadcastEventSpec event_spec) { Mutex::Locker locker(m_manager_mutex); @@ -380,23 +408,23 @@ BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEven if (available_bits != 0) { - m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener)); - m_listeners.insert(&listener); + m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), listener_sp)); + m_listeners.insert(listener_sp); } return available_bits; } bool -BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec) +BroadcasterManager::UnregisterListenerForEvents (ListenerSP listener_sp, BroadcastEventSpec event_spec) { Mutex::Locker locker(m_manager_mutex); bool removed_some = false; - if (m_listeners.erase(&listener) == 0) + if (m_listeners.erase(listener_sp) == 0) return false; - ListenerMatchesAndSharedBits predicate (event_spec, listener); + ListenerMatchesAndSharedBits predicate (event_spec, listener_sp); std::vector<BroadcastEventSpec> to_be_readded; uint32_t event_bits_to_remove = event_spec.GetEventBits(); @@ -426,13 +454,13 @@ BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEv // Okay now add back the bits that weren't completely removed: for (size_t i = 0; i < to_be_readded.size(); i++) { - m_event_map.insert (event_listener_key (to_be_readded[i], &listener)); + m_event_map.insert (event_listener_key (to_be_readded[i], listener_sp)); } return removed_some; } -Listener * +ListenerSP BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const { Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex))); @@ -446,12 +474,34 @@ BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) cons } void -BroadcasterManager::RemoveListener (Listener &listener) +BroadcasterManager::RemoveListener(Listener *listener) +{ + Mutex::Locker locker(m_manager_mutex); + ListenerMatchesPointer predicate (listener); + listener_collection::iterator iter = m_listeners.begin(), end_iter = m_listeners.end(); + + std::find_if (iter, end_iter, predicate); + if (iter != end_iter) + m_listeners.erase(iter); + + while (true) + { + collection::iterator iter, end_iter = m_event_map.end(); + iter = find_if (m_event_map.begin(), end_iter, predicate); + if (iter == end_iter) + break; + else + m_event_map.erase(iter); + } +} + +void +BroadcasterManager::RemoveListener (ListenerSP listener_sp) { Mutex::Locker locker(m_manager_mutex); - ListenerMatches predicate (listener); + ListenerMatches predicate (listener_sp); - if (m_listeners.erase (&listener) == 0) + if (m_listeners.erase (listener_sp) == 0) return; while (true) @@ -487,7 +537,7 @@ BroadcasterManager::Clear () listener_collection::iterator end_iter = m_listeners.end(); for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++) - (*iter)->BroadcasterManagerWillDestruct(this); + (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this()); m_listeners.clear(); m_event_map.clear(); } diff --git a/lldb/source/Core/Communication.cpp b/lldb/source/Core/Communication.cpp index ab2b293f8c3..557fb95df69 100644 --- a/lldb/source/Core/Communication.cpp +++ b/lldb/source/Core/Communication.cpp @@ -15,6 +15,7 @@ // Project includes #include "lldb/Core/Communication.h" #include "lldb/Core/Connection.h" +#include "lldb/Core/Listener.h" #include "lldb/Core/Log.h" #include "lldb/Core/Timer.h" #include "lldb/Core/Event.h" @@ -64,7 +65,7 @@ Communication::~Communication() { lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_COMMUNICATION, "%p Communication::~Communication (name = %s)", - this, m_broadcaster_name.AsCString("")); + this, GetBroadcasterName().AsCString()); Clear(); } @@ -164,10 +165,10 @@ Communication::Read (void *dst, size_t dst_len, uint32_t timeout_usec, Connectio timeout_time.OffsetWithMicroSeconds (timeout_usec); } - Listener listener ("Communication::Read"); - listener.StartListeningForEvents (this, eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit); + ListenerSP listener_sp(Listener::MakeListener("Communication::Read")); + listener_sp->StartListeningForEvents (this, eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit); EventSP event_sp; - while (listener.WaitForEvent((timeout_time.IsValid() ? &timeout_time : nullptr), event_sp)) + while (listener_sp->WaitForEvent (timeout_time.IsValid() ? &timeout_time : nullptr, event_sp)) { const uint32_t event_type = event_sp->GetType(); if (event_type & eBroadcastBitReadThreadGotBytes) @@ -234,7 +235,7 @@ Communication::StartReadThread (Error *error_ptr) "%p Communication::StartReadThread ()", this); char thread_name[1024]; - snprintf(thread_name, sizeof(thread_name), "<lldb.comm.%s>", m_broadcaster_name.AsCString()); + snprintf(thread_name, sizeof(thread_name), "<lldb.comm.%s>", GetBroadcasterName().AsCString()); m_read_thread_enabled = true; m_read_thread_did_exit = false; @@ -427,8 +428,8 @@ Communication::SynchronizeWithReadThread () Mutex::Locker locker(m_synchronize_mutex); // First start listening for the synchronization event. - Listener listener("Communication::SyncronizeWithReadThread"); - listener.StartListeningForEvents(this, eBroadcastBitNoMorePendingInput); + ListenerSP listener_sp(Listener::MakeListener("Communication::SyncronizeWithReadThread")); + listener_sp->StartListeningForEvents(this, eBroadcastBitNoMorePendingInput); // If the thread is not running, there is no point in synchronizing. if (!m_read_thread_enabled || m_read_thread_did_exit) @@ -439,7 +440,7 @@ Communication::SynchronizeWithReadThread () // Wait for the synchronization event. EventSP event_sp; - listener.WaitForEvent(nullptr, event_sp); + listener_sp->WaitForEvent(nullptr, event_sp); } void diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp index f348bb00790..57313a45d37 100644 --- a/lldb/source/Core/Debugger.cpp +++ b/lldb/source/Core/Debugger.cpp @@ -702,10 +702,11 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) : m_input_file_sp(new StreamFile(stdin, false)), m_output_file_sp(new StreamFile(stdout, false)), m_error_file_sp(new StreamFile(stderr, false)), + m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()), m_terminal_state(), m_target_list(*this), m_platform_list(), - m_listener("lldb.Debugger"), + m_listener_sp(Listener::MakeListener("lldb.Debugger")), m_source_manager_ap(), m_source_file_cache(), m_command_interpreter_ap(new CommandInterpreter(*this, eScriptLanguageDefault, false)), @@ -764,7 +765,7 @@ Debugger::Clear() ClearIOHandlers(); StopIOHandlerThread(); StopEventHandlerThread(); - m_listener.Clear(); + m_listener_sp->Clear(); int num_targets = m_target_list.GetNumTargets(); for (int i = 0; i < num_targets; i++) { @@ -777,7 +778,7 @@ Debugger::Clear() target_sp->Destroy(); } } - BroadcasterManager::Clear (); + m_broadcaster_manager_sp->Clear (); // Close the input file _before_ we close the input read communications class // as it does NOT own the input file, our m_input_file does. @@ -1580,7 +1581,7 @@ Debugger::CancelForwardEvents (const ListenerSP &listener_sp) void Debugger::DefaultEventHandler() { - Listener& listener(GetListener()); + ListenerSP listener_sp(GetListener()); ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass()); ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass()); ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass()); @@ -1596,10 +1597,10 @@ Debugger::DefaultEventHandler() Thread::eBroadcastBitStackChanged | Thread::eBroadcastBitThreadSelected ); - listener.StartListeningForEventSpec (*this, target_event_spec); - listener.StartListeningForEventSpec (*this, process_event_spec); - listener.StartListeningForEventSpec (*this, thread_event_spec); - listener.StartListeningForEvents (m_command_interpreter_ap.get(), + listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, target_event_spec); + listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, process_event_spec); + listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, thread_event_spec); + listener_sp->StartListeningForEvents (m_command_interpreter_ap.get(), CommandInterpreter::eBroadcastBitQuitCommandReceived | CommandInterpreter::eBroadcastBitAsynchronousOutputData | CommandInterpreter::eBroadcastBitAsynchronousErrorData ); @@ -1612,7 +1613,7 @@ Debugger::DefaultEventHandler() while (!done) { EventSP event_sp; - if (listener.WaitForEvent(nullptr, event_sp)) + if (listener_sp->WaitForEvent(nullptr, event_sp)) { if (event_sp) { @@ -1694,8 +1695,8 @@ Debugger::StartEventHandlerThread() // it is up and running and listening to events before we return from // this function. We do this by listening to events for the // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster - Listener listener("lldb.debugger.event-handler"); - listener.StartListeningForEvents(&m_sync_broadcaster, eBroadcastBitEventThreadIsListening); + ListenerSP listener_sp(Listener::MakeListener("lldb.debugger.event-handler")); + listener_sp->StartListeningForEvents(&m_sync_broadcaster, eBroadcastBitEventThreadIsListening); // Use larger 8MB stack for this thread m_event_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.event-handler", @@ -1709,7 +1710,7 @@ Debugger::StartEventHandlerThread() // eBroadcastBitEventThreadIsListening so we don't need to check the event, we just need // to wait an infinite amount of time for it (nullptr timeout as the first parameter) lldb::EventSP event_sp; - listener.WaitForEvent(nullptr, event_sp); + listener_sp->WaitForEvent(nullptr, event_sp); } return m_event_handler_thread.IsJoinable(); } diff --git a/lldb/source/Core/Event.cpp b/lldb/source/Core/Event.cpp index 293a322257e..8e2006330b5 100644 --- a/lldb/source/Core/Event.cpp +++ b/lldb/source/Core/Event.cpp @@ -28,14 +28,13 @@ using namespace lldb_private; // Event constructor //---------------------------------------------------------------------- Event::Event (Broadcaster *broadcaster, uint32_t event_type, EventData *data) : - m_broadcaster (broadcaster), + m_broadcaster_wp (broadcaster->GetBroadcasterImpl()), m_type (event_type), m_data_ap (data) { } Event::Event(uint32_t event_type, EventData *data) : - m_broadcaster (NULL), // Set by the broadcaster when this event gets broadcast m_type (event_type), m_data_ap (data) { @@ -52,20 +51,27 @@ Event::~Event () void Event::Dump (Stream *s) const { - if (m_broadcaster) + Broadcaster *broadcaster; + Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock()); + if (broadcaster_impl_sp) + broadcaster = broadcaster_impl_sp->GetBroadcaster(); + else + broadcaster = nullptr; + + if (broadcaster) { StreamString event_name; - if (m_broadcaster->GetEventNames (event_name, m_type, false)) + if (broadcaster->GetEventNames (event_name, m_type, false)) s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ", static_cast<const void*>(this), - static_cast<void*>(m_broadcaster), - m_broadcaster->GetBroadcasterName().GetCString(), + static_cast<void*>(broadcaster), + broadcaster->GetBroadcasterName().GetCString(), m_type, event_name.GetString().c_str()); else s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ", static_cast<const void*>(this), - static_cast<void*>(m_broadcaster), - m_broadcaster->GetBroadcasterName().GetCString(), m_type); + static_cast<void*>(broadcaster), + broadcaster->GetBroadcasterName().GetCString(), m_type); } else s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ", diff --git a/lldb/source/Core/IOHandler.cpp b/lldb/source/Core/IOHandler.cpp index 47d00e9184c..ea5624a5220 100644 --- a/lldb/source/Core/IOHandler.cpp +++ b/lldb/source/Core/IOHandler.cpp @@ -2369,7 +2369,7 @@ type summary add -s "${var.origin%S} ${var.size%S}" curses::Rect halfdelay(delay_in_tenths_of_a_second); // Poll using some number of tenths of seconds seconds when calling Window::GetChar() - ListenerSP listener_sp (new Listener ("lldb.IOHandler.curses.Application")); + ListenerSP listener_sp (Listener::MakeListener("lldb.IOHandler.curses.Application")); ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass()); ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass()); ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass()); diff --git a/lldb/source/Core/Listener.cpp b/lldb/source/Core/Listener.cpp index 34475498d48..d13a203d2da 100644 --- a/lldb/source/Core/Listener.cpp +++ b/lldb/source/Core/Listener.cpp @@ -23,6 +23,24 @@ using namespace lldb; using namespace lldb_private; +namespace +{ + class BroadcasterManagerWPMatcher + { + public: + BroadcasterManagerWPMatcher (BroadcasterManagerSP manager_sp) : m_manager_sp(manager_sp) {} + bool operator() (const BroadcasterManagerWP input_wp) const + { + BroadcasterManagerSP input_sp = input_wp.lock(); + if (input_sp && input_sp == m_manager_sp) + return true; + else + return false; + } + BroadcasterManagerSP m_manager_sp; + }; +} + Listener::Listener(const char *name) : m_name (name), m_broadcasters(), @@ -39,32 +57,40 @@ Listener::Listener(const char *name) : Listener::~Listener() { - Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); Mutex::Locker locker (m_broadcasters_mutex); - size_t num_managers = m_broadcaster_managers.size(); - - for (size_t i = 0; i < num_managers; i++) - m_broadcaster_managers[i]->RemoveListener(*this); - - if (log) - log->Printf ("%p Listener::~Listener('%s')", - static_cast<void*>(this), m_name.c_str()); Clear(); } void Listener::Clear() { + Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); Mutex::Locker locker(m_broadcasters_mutex); broadcaster_collection::iterator pos, end = m_broadcasters.end(); for (pos = m_broadcasters.begin(); pos != end; ++pos) - pos->first->RemoveListener (this, pos->second.event_mask); + { + Broadcaster::BroadcasterImplSP broadcaster_sp(pos->first.lock()); + if (broadcaster_sp) + broadcaster_sp->RemoveListener (this->shared_from_this(), pos->second.event_mask); + } m_broadcasters.clear(); m_cond_wait.SetValue (false, eBroadcastNever); m_broadcasters.clear(); Mutex::Locker event_locker(m_events_mutex); m_events.clear(); + size_t num_managers = m_broadcaster_managers.size(); + + for (size_t i = 0; i < num_managers; i++) + { + BroadcasterManagerSP manager_sp(m_broadcaster_managers[i].lock()); + if (manager_sp) + manager_sp->RemoveListener(this); + } + + if (log) + log->Printf ("%p Listener::~Listener('%s')", + static_cast<void*>(this), m_name.c_str()); } uint32_t @@ -76,10 +102,11 @@ Listener::StartListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask // Tell the broadcaster to add this object as a listener { Mutex::Locker locker(m_broadcasters_mutex); - m_broadcasters.insert(std::make_pair(broadcaster, BroadcasterInfo(event_mask))); + Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl()); + m_broadcasters.insert(std::make_pair(impl_wp, BroadcasterInfo(event_mask))); } - uint32_t acquired_mask = broadcaster->AddListener (this, event_mask); + uint32_t acquired_mask = broadcaster->AddListener (this->shared_from_this(), event_mask); if (event_mask != acquired_mask) { @@ -107,10 +134,12 @@ Listener::StartListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask // Tell the broadcaster to add this object as a listener { Mutex::Locker locker(m_broadcasters_mutex); - m_broadcasters.insert(std::make_pair(broadcaster, BroadcasterInfo(event_mask, callback, callback_user_data))); + Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl()); + m_broadcasters.insert(std::make_pair(impl_wp, + BroadcasterInfo(event_mask, callback, callback_user_data))); } - uint32_t acquired_mask = broadcaster->AddListener (this, event_mask); + uint32_t acquired_mask = broadcaster->AddListener (this->shared_from_this(), event_mask); Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS)); if (log) @@ -136,10 +165,10 @@ Listener::StopListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask) // Scope for "locker" { Mutex::Locker locker(m_broadcasters_mutex); - m_broadcasters.erase (broadcaster); + m_broadcasters.erase (broadcaster->GetBroadcasterImpl()); } // Remove the broadcaster from our set of broadcasters - return broadcaster->RemoveListener (this, event_mask); + return broadcaster->RemoveListener (this->shared_from_this(), event_mask); } return false; @@ -153,7 +182,7 @@ Listener::BroadcasterWillDestruct (Broadcaster *broadcaster) // Scope for "broadcasters_locker" { Mutex::Locker broadcasters_locker(m_broadcasters_mutex); - m_broadcasters.erase (broadcaster); + m_broadcasters.erase (broadcaster->GetBroadcasterImpl()); } // Scope for "event_locker" @@ -176,11 +205,14 @@ Listener::BroadcasterWillDestruct (Broadcaster *broadcaster) } void -Listener::BroadcasterManagerWillDestruct (BroadcasterManager *manager) +Listener::BroadcasterManagerWillDestruct (BroadcasterManagerSP manager_sp) { // Just need to remove this broadcast manager from the list of managers: broadcaster_manager_collection::iterator iter, end_iter = m_broadcaster_managers.end(); - iter = find(m_broadcaster_managers.begin(), end_iter, manager); + BroadcasterManagerWP manager_wp; + + BroadcasterManagerWPMatcher matcher(manager_sp); + iter = std::find_if<broadcaster_manager_collection::iterator, BroadcasterManagerWPMatcher>(m_broadcaster_managers.begin(), end_iter, matcher); if (iter != end_iter) m_broadcaster_managers.erase (iter); } @@ -206,7 +238,8 @@ class EventBroadcasterMatches { public: EventBroadcasterMatches (Broadcaster *broadcaster) : - m_broadcaster (broadcaster) { + m_broadcaster (broadcaster) + { } bool operator() (const EventSP &event_sp) const @@ -486,39 +519,19 @@ Listener::WaitForEvent (const TimeValue *timeout, EventSP &event_sp) return WaitForEventsInternal (timeout, NULL, NULL, 0, 0, event_sp); } -//Listener::broadcaster_collection::iterator -//Listener::FindBroadcasterWithMask (Broadcaster *broadcaster, uint32_t event_mask, bool exact) -//{ -// broadcaster_collection::iterator pos; -// broadcaster_collection::iterator end = m_broadcasters.end(); -// for (pos = m_broadcasters.find (broadcaster); -// pos != end && pos->first == broadcaster; -// ++pos) -// { -// if (exact) -// { -// if ((event_mask & pos->second.event_mask) == event_mask) -// return pos; -// } -// else -// { -// if (event_mask & pos->second.event_mask) -// return pos; -// } -// } -// return end; -//} - size_t Listener::HandleBroadcastEvent (EventSP &event_sp) { size_t num_handled = 0; Mutex::Locker locker(m_broadcasters_mutex); Broadcaster *broadcaster = event_sp->GetBroadcaster(); + if (!broadcaster) + return 0; broadcaster_collection::iterator pos; broadcaster_collection::iterator end = m_broadcasters.end(); - for (pos = m_broadcasters.find (broadcaster); - pos != end && pos->first == broadcaster; + Broadcaster::BroadcasterImplSP broadcaster_impl_sp(broadcaster->GetBroadcasterImpl()); + for (pos = m_broadcasters.find (broadcaster_impl_sp); + pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) { BroadcasterInfo info = pos->second; @@ -535,28 +548,45 @@ Listener::HandleBroadcastEvent (EventSP &event_sp) } uint32_t -Listener::StartListeningForEventSpec (BroadcasterManager &manager, +Listener::StartListeningForEventSpec (BroadcasterManagerSP manager_sp, const BroadcastEventSpec &event_spec) { + if (!manager_sp) + return 0; + // The BroadcasterManager mutex must be locked before m_broadcasters_mutex // to avoid violating the lock hierarchy (manager before broadcasters). - Mutex::Locker manager_locker(manager.m_manager_mutex); + Mutex::Locker manager_locker(manager_sp->m_manager_mutex); Mutex::Locker locker(m_broadcasters_mutex); - uint32_t bits_acquired = manager.RegisterListenerForEvents(*this, event_spec); + uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(this->shared_from_this(), event_spec); if (bits_acquired) - m_broadcaster_managers.push_back(&manager); - + { + broadcaster_manager_collection::iterator iter, end_iter = m_broadcaster_managers.end(); + BroadcasterManagerWP manager_wp(manager_sp); + BroadcasterManagerWPMatcher matcher(manager_sp); + iter = std::find_if<broadcaster_manager_collection::iterator, BroadcasterManagerWPMatcher>(m_broadcaster_managers.begin(), end_iter, matcher); + if (iter == end_iter) + m_broadcaster_managers.push_back(manager_wp); + } + return bits_acquired; } bool -Listener::StopListeningForEventSpec (BroadcasterManager &manager, +Listener::StopListeningForEventSpec (BroadcasterManagerSP manager_sp, const BroadcastEventSpec &event_spec) { + if (!manager_sp) + return false; + Mutex::Locker locker(m_broadcasters_mutex); - return manager.UnregisterListenerForEvents (*this, event_spec); + return manager_sp->UnregisterListenerForEvents (this->shared_from_this(), event_spec); } - +ListenerSP +Listener::MakeListener(const char *name) +{ + return ListenerSP(new Listener(name)); +} diff --git a/lldb/source/Interpreter/CommandInterpreter.cpp b/lldb/source/Interpreter/CommandInterpreter.cpp index 5de6177f00c..3a1e187da6c 100644 --- a/lldb/source/Interpreter/CommandInterpreter.cpp +++ b/lldb/source/Interpreter/CommandInterpreter.cpp @@ -105,7 +105,7 @@ CommandInterpreter::GetStaticBroadcasterClass () } CommandInterpreter::CommandInterpreter(Debugger &debugger, ScriptLanguage script_language, bool synchronous_execution) - : Broadcaster(&debugger, CommandInterpreter::GetStaticBroadcasterClass().AsCString()), + : Broadcaster(debugger.GetBroadcasterManager(), CommandInterpreter::GetStaticBroadcasterClass().AsCString()), Properties(OptionValuePropertiesSP(new OptionValueProperties(ConstString("interpreter")))), IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand), m_debugger(debugger), diff --git a/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp b/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp index f6d843ec3af..92f6ef90afc 100644 --- a/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp +++ b/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp @@ -670,9 +670,9 @@ PlatformLinux::DebugProcess (ProcessLaunchInfo &launch_info, if (log) log->Printf ("PlatformLinux::%s setting up hijacker", __FUNCTION__); - listener_sp.reset (new Listener("lldb.PlatformLinux.DebugProcess.hijack")); + listener_sp = Listener::MakeListener("lldb.PlatformLinux.DebugProcess.hijack"); launch_info.SetHijackListener (listener_sp); - process_sp->HijackProcessEvents (listener_sp.get ()); + process_sp->HijackProcessEvents (listener_sp); } // Log file actions. @@ -698,7 +698,7 @@ PlatformLinux::DebugProcess (ProcessLaunchInfo &launch_info, // Handle the hijacking of process events. if (listener_sp) { - const StateType state = process_sp->WaitForProcessToStop (NULL, NULL, false, listener_sp.get()); + const StateType state = process_sp->WaitForProcessToStop (NULL, NULL, false, listener_sp); if (state == eStateStopped) { diff --git a/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp b/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp index 3482b608bcc..031b0005a91 100644 --- a/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp +++ b/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp @@ -799,13 +799,13 @@ PlatformPOSIX::Attach (ProcessAttachInfo &attach_info, if (process_sp) { - auto listener_sp = attach_info.GetHijackListener(); + ListenerSP listener_sp = attach_info.GetHijackListener(); if (listener_sp == nullptr) { - listener_sp.reset(new Listener("lldb.PlatformPOSIX.attach.hijack")); + listener_sp = Listener::MakeListener("lldb.PlatformPOSIX.attach.hijack"); attach_info.SetHijackListener(listener_sp); } - process_sp->HijackProcessEvents(listener_sp.get()); + process_sp->HijackProcessEvents(listener_sp); error = process_sp->Attach (attach_info); } } diff --git a/lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp b/lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp index a0ff837dc15..cef5684d9ba 100644 --- a/lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp +++ b/lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp @@ -565,7 +565,7 @@ PlatformWindows::Attach(ProcessAttachInfo &attach_info, const char *plugin_name = attach_info.GetProcessPluginName(); process_sp = target->CreateProcess(attach_info.GetListenerForProcess(debugger), plugin_name, nullptr); - process_sp->HijackProcessEvents(attach_info.GetHijackListener().get()); + process_sp->HijackProcessEvents(attach_info.GetHijackListener()); if (process_sp) error = process_sp->Attach (attach_info); diff --git a/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp b/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp index f16ea017676..cecc96c6323 100644 --- a/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp +++ b/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp @@ -714,9 +714,9 @@ PlatformRemoteGDBServer::Attach (ProcessAttachInfo &attach_info, error = process_sp->ConnectRemote(nullptr, connect_url.c_str()); if (error.Success()) { - auto listener = attach_info.GetHijackListener(); - if (listener != nullptr) - process_sp->HijackProcessEvents(listener.get()); + ListenerSP listener_sp = attach_info.GetHijackListener(); + if (listener_sp) + process_sp->HijackProcessEvents(listener_sp); error = process_sp->Attach(attach_info); } diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp index 769ccd7248a..69b527a513f 100644 --- a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp +++ b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp @@ -63,12 +63,12 @@ namespace lldb::ProcessSP ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp, - Listener &listener, + lldb::ListenerSP listener_sp, const FileSpec *crash_file_path) { lldb::ProcessSP process_sp; if (crash_file_path == NULL) - process_sp.reset(new ProcessFreeBSD (target_sp, listener, GetFreeBSDSignals())); + process_sp.reset(new ProcessFreeBSD (target_sp, listener_sp, GetFreeBSDSignals())); return process_sp; } @@ -269,8 +269,8 @@ ProcessFreeBSD::SendMessage(const ProcessMessage &message) //------------------------------------------------------------------------------ // Constructors and destructors. -ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp, Listener &listener, UnixSignalsSP &unix_signals_sp) - : Process(target_sp, listener, unix_signals_sp), +ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, UnixSignalsSP &unix_signals_sp) + : Process(target_sp, listener_sp, unix_signals_sp), m_byte_order(endian::InlHostByteOrder()), m_monitor(NULL), m_module(NULL), diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h index 5f9365418d7..a1d255c34cb 100644 --- a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h +++ b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h @@ -35,7 +35,7 @@ public: //------------------------------------------------------------------ static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, const lldb_private::FileSpec *crash_file_path); static void @@ -54,7 +54,7 @@ public: // Constructors and destructors //------------------------------------------------------------------ ProcessFreeBSD(lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, lldb::UnixSignalsSP &unix_signals_sp); ~ProcessFreeBSD(); diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp index 628f76d104f..f99bb2c0e9f 100644 --- a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp +++ b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp @@ -132,12 +132,12 @@ ProcessKDP::Terminate() lldb::ProcessSP ProcessKDP::CreateInstance (TargetSP target_sp, - Listener &listener, + ListenerSP listener_sp, const FileSpec *crash_file_path) { lldb::ProcessSP process_sp; if (crash_file_path == NULL) - process_sp.reset(new ProcessKDP (target_sp, listener)); + process_sp.reset(new ProcessKDP (target_sp, listener_sp)); return process_sp; } @@ -178,8 +178,8 @@ ProcessKDP::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) //---------------------------------------------------------------------- // ProcessKDP constructor //---------------------------------------------------------------------- -ProcessKDP::ProcessKDP(TargetSP target_sp, Listener &listener) : - Process (target_sp, listener), +ProcessKDP::ProcessKDP(TargetSP target_sp, ListenerSP listener_sp) : + Process (target_sp, listener_sp), m_comm("lldb.process.kdp-remote.communication"), m_async_broadcaster (NULL, "lldb.process.kdp-remote.async-broadcaster"), m_dyld_plugin_name (), @@ -927,13 +927,13 @@ ProcessKDP::AsyncThread (void *arg) if (log) log->Printf ("ProcessKDP::AsyncThread (arg = %p, pid = %" PRIu64 ") thread starting...", arg, pid); - Listener listener ("ProcessKDP::AsyncThread"); + ListenerSP listener_sp (Listener::MakeListener("ProcessKDP::AsyncThread")); EventSP event_sp; const uint32_t desired_event_mask = eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit; - if (listener.StartListeningForEvents (&process->m_async_broadcaster, desired_event_mask) == desired_event_mask) + if (listener_sp->StartListeningForEvents (&process->m_async_broadcaster, desired_event_mask) == desired_event_mask) { bool done = false; while (!done) @@ -941,7 +941,7 @@ ProcessKDP::AsyncThread (void *arg) if (log) log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp)...", pid); - if (listener.WaitForEvent (NULL, event_sp)) + if (listener_sp->WaitForEvent (NULL, event_sp)) { uint32_t event_type = event_sp->GetType(); if (log) @@ -981,7 +981,7 @@ ProcessKDP::AsyncThread (void *arg) // Check to see if we are supposed to exit. There is no way to // interrupt a running kernel, so all we can do is wait for an // exception or detach... - if (listener.GetNextEvent(event_sp)) + if (listener_sp->GetNextEvent(event_sp)) { // We got an event, go through the loop again event_type = event_sp->GetType(); diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h index fe9a4e2844b..49f63624251 100644 --- a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h +++ b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h @@ -40,7 +40,7 @@ public: //------------------------------------------------------------------ static lldb::ProcessSP CreateInstance (lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, const lldb_private::FileSpec *crash_file_path); static void @@ -61,7 +61,7 @@ public: //------------------------------------------------------------------ // Constructors and Destructors //------------------------------------------------------------------ - ProcessKDP(lldb::TargetSP target_sp, lldb_private::Listener &listener); + ProcessKDP(lldb::TargetSP target_sp, lldb::ListenerSP listener); virtual ~ProcessKDP(); diff --git a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp index 0e6900d8fb7..2c3f9fbecf9 100644 --- a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp +++ b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp @@ -29,8 +29,8 @@ namespace lldb_private //------------------------------------------------------------------------------ // Constructors and destructors. -ProcessWindows::ProcessWindows(lldb::TargetSP target_sp, Listener &listener) - : lldb_private::Process(target_sp, listener) +ProcessWindows::ProcessWindows(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp) + : lldb_private::Process(target_sp, listener_sp) { } diff --git a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h index 2a437c0ca90..0ee42e2ae1f 100644 --- a/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h +++ b/lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h @@ -25,7 +25,7 @@ public: // Constructors and destructors //------------------------------------------------------------------ ProcessWindows(lldb::TargetSP target_sp, - lldb_private::Listener &listener); + lldb::ListenerSP listener_sp); ~ProcessWindows(); diff --git a/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp index 45ef8366f8f..9516040edc6 100644 --- a/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp +++ b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp @@ -121,9 +121,9 @@ class ProcessWindowsData // Static functions. ProcessSP -ProcessWindowsLive::CreateInstance(lldb::TargetSP target_sp, Listener &listener, const FileSpec *) +ProcessWindowsLive::CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *) { - return ProcessSP(new ProcessWindowsLive(target_sp, listener)); + return ProcessSP(new ProcessWindowsLive(target_sp, listener_sp)); } void @@ -142,8 +142,8 @@ ProcessWindowsLive::Initialize() //------------------------------------------------------------------------------ // Constructors and destructors. -ProcessWindowsLive::ProcessWindowsLive(lldb::TargetSP target_sp, Listener &listener) - : lldb_private::ProcessWindows(target_sp, listener) +ProcessWindowsLive::ProcessWindowsLive(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp) + : lldb_private::ProcessWindows(target_sp, listener_sp) { } diff --git a/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.h b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.h index 2429f873c82..657877f529b 100644 --- a/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.h +++ b/lldb/source/Plugins/Process/Windows/Live/ProcessWindowsLive.h @@ -43,7 +43,7 @@ public: //------------------------------------------------------------------ static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, const lldb_private::FileSpec *); static void @@ -62,7 +62,7 @@ public: // Constructors and destructors //------------------------------------------------------------------ ProcessWindowsLive(lldb::TargetSP target_sp, - lldb_private::Listener &listener); + lldb::ListenerSP listener_sp); ~ProcessWindowsLive(); diff --git a/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp index 1343886fa9d..c39f77f441e 100644 --- a/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp +++ b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp @@ -538,7 +538,7 @@ ProcessWinMiniDump::Terminate() } lldb::ProcessSP -ProcessWinMiniDump::CreateInstance(lldb::TargetSP target_sp, Listener &listener, const FileSpec *crash_file) +ProcessWinMiniDump::CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file) { lldb::ProcessSP process_sp; if (crash_file) @@ -555,8 +555,8 @@ ProcessWinMiniDump::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_ return true; } -ProcessWinMiniDump::ProcessWinMiniDump(lldb::TargetSP target_sp, Listener &listener, const FileSpec &core_file) - : ProcessWindows(target_sp, listener), m_impl_up(new Impl(core_file, this)) +ProcessWinMiniDump::ProcessWinMiniDump(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec &core_file) + : ProcessWindows(target_sp, listener_sp), m_impl_up(new Impl(core_file, this)) { } diff --git a/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h index 4239115576b..3e1ac4bffbe 100644 --- a/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h +++ b/lldb/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h @@ -26,7 +26,7 @@ class ProcessWinMiniDump : public lldb_private::ProcessWindows public: static lldb::ProcessSP CreateInstance (lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, const lldb_private::FileSpec *crash_file_path); static void @@ -42,7 +42,7 @@ class ProcessWinMiniDump : public lldb_private::ProcessWindows GetPluginDescriptionStatic(); ProcessWinMiniDump(lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, const lldb_private::FileSpec &core_file); virtual diff --git a/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp b/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp index a2f73ec5e3c..db56cc38140 100644 --- a/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp +++ b/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp @@ -57,7 +57,7 @@ ProcessElfCore::Terminate() lldb::ProcessSP -ProcessElfCore::CreateInstance (lldb::TargetSP target_sp, Listener &listener, const FileSpec *crash_file) +ProcessElfCore::CreateInstance (lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file) { lldb::ProcessSP process_sp; if (crash_file) @@ -75,7 +75,7 @@ ProcessElfCore::CreateInstance (lldb::TargetSP target_sp, Listener &listener, co if (elf_header.Parse(data, &data_offset)) { if (elf_header.e_type == llvm::ELF::ET_CORE) - process_sp.reset(new ProcessElfCore (target_sp, listener, *crash_file)); + process_sp.reset(new ProcessElfCore (target_sp, listener_sp, *crash_file)); } } } @@ -104,9 +104,9 @@ ProcessElfCore::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name //---------------------------------------------------------------------- // ProcessElfCore constructor //---------------------------------------------------------------------- -ProcessElfCore::ProcessElfCore(lldb::TargetSP target_sp, Listener &listener, +ProcessElfCore::ProcessElfCore(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec &core_file) : - Process (target_sp, listener), + Process (target_sp, listener_sp), m_core_module_sp (), m_core_file (core_file), m_dyld_plugin_name (), diff --git a/lldb/source/Plugins/Process/elf-core/ProcessElfCore.h b/lldb/source/Plugins/Process/elf-core/ProcessElfCore.h index 12ce04c5ce3..48220f4e11c 100644 --- a/lldb/source/Plugins/Process/elf-core/ProcessElfCore.h +++ b/lldb/source/Plugins/Process/elf-core/ProcessElfCore.h @@ -40,7 +40,7 @@ public: //------------------------------------------------------------------ static lldb::ProcessSP CreateInstance (lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, const lldb_private::FileSpec *crash_file_path); static void @@ -59,7 +59,7 @@ public: // Constructors and Destructors //------------------------------------------------------------------ ProcessElfCore(lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener_sp, const lldb_private::FileSpec &core_file); ~ProcessElfCore() override; diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp index da04d48910e..e61999dbf2a 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp @@ -786,8 +786,8 @@ GDBRemoteCommunicationClient::SendPacketAndWaitForResponse // In order to stop async notifications from being processed in the middle of the // send/receive sequence Hijack the broadcast. Then rebroadcast any events when we are done. - static Listener hijack_listener("lldb.NotifyHijacker"); - HijackBroadcaster(&hijack_listener, eBroadcastBitGdbReadThreadGotNotify); + static ListenerSP hijack_listener_sp(Listener::MakeListener("lldb.NotifyHijacker")); + HijackBroadcaster(hijack_listener_sp, eBroadcastBitGdbReadThreadGotNotify); if (GetSequenceMutex (locker)) { @@ -886,7 +886,7 @@ GDBRemoteCommunicationClient::SendPacketAndWaitForResponse // If a notification event occurred, rebroadcast since it can now be processed safely. EventSP event_sp; - if (hijack_listener.GetNextEvent(event_sp)) + if (hijack_listener_sp->GetNextEvent(event_sp)) BroadcastEvent(event_sp); return packet_result; diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp index 6b0637a76e7..e666b852ba3 100644 --- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp @@ -223,11 +223,11 @@ ProcessGDBRemote::Terminate() lldb::ProcessSP -ProcessGDBRemote::CreateInstance (lldb::TargetSP target_sp, Listener &listener, const FileSpec *crash_file_path) +ProcessGDBRemote::CreateInstance (lldb::TargetSP target_sp, ListenerSP listener_sp, const FileSpec *crash_file_path) { lldb::ProcessSP process_sp; if (crash_file_path == NULL) - process_sp.reset (new ProcessGDBRemote (target_sp, listener)); + process_sp.reset (new ProcessGDBRemote (target_sp, listener_sp)); return process_sp; } @@ -267,15 +267,15 @@ ProcessGDBRemote::CanDebug (lldb::TargetSP target_sp, bool plugin_specified_by_n //---------------------------------------------------------------------- // ProcessGDBRemote constructor //---------------------------------------------------------------------- -ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, Listener &listener) : - Process (target_sp, listener), +ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, ListenerSP listener_sp) : + Process (target_sp, listener_sp), m_flags (0), m_gdb_comm (), m_debugserver_pid (LLDB_INVALID_PROCESS_ID), m_last_stop_packet_mutex (Mutex::eMutexTypeRecursive), m_register_info (), m_async_broadcaster (NULL, "lldb.process.gdb-remote.async-broadcaster"), - m_async_listener("lldb.process.gdb-remote.async-listener"), + m_async_listener_sp(Listener::MakeListener("lldb.process.gdb-remote.async-listener")), m_async_thread_state_mutex(Mutex::eMutexTypeRecursive), m_thread_ids (), m_thread_pcs (), @@ -303,7 +303,7 @@ ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, Listener &listener) const uint32_t async_event_mask = eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit; - if (m_async_listener.StartListeningForEvents(&m_async_broadcaster, async_event_mask) != async_event_mask) + if (m_async_listener_sp->StartListeningForEvents(&m_async_broadcaster, async_event_mask) != async_event_mask) { if (log) log->Printf("ProcessGDBRemote::%s failed to listen for m_async_broadcaster events", __FUNCTION__); @@ -311,7 +311,7 @@ ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, Listener &listener) const uint32_t gdb_event_mask = Communication::eBroadcastBitReadThreadDidExit | GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify; - if (m_async_listener.StartListeningForEvents(&m_gdb_comm, gdb_event_mask) != gdb_event_mask) + if (m_async_listener_sp->StartListeningForEvents(&m_gdb_comm, gdb_event_mask) != gdb_event_mask) { if (log) log->Printf("ProcessGDBRemote::%s failed to listen for m_gdb_comm events", __FUNCTION__); @@ -1368,10 +1368,10 @@ ProcessGDBRemote::DoResume () if (log) log->Printf ("ProcessGDBRemote::Resume()"); - Listener listener ("gdb-remote.resume-packet-sent"); - if (listener.StartListeningForEvents (&m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent)) + ListenerSP listener_sp (Listener::MakeListener("gdb-remote.resume-packet-sent")); + if (listener_sp->StartListeningForEvents (&m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent)) { - listener.StartListeningForEvents (&m_async_broadcaster, ProcessGDBRemote::eBroadcastBitAsyncThreadDidExit); + listener_sp->StartListeningForEvents (&m_async_broadcaster, ProcessGDBRemote::eBroadcastBitAsyncThreadDidExit); const size_t num_threads = GetThreadList().GetSize(); @@ -1603,7 +1603,7 @@ ProcessGDBRemote::DoResume () m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (continue_packet.GetData(), continue_packet.GetSize())); - if (listener.WaitForEvent (&timeout, event_sp) == false) + if (listener_sp->WaitForEvent (&timeout, event_sp) == false) { error.SetErrorString("Resume timed out."); if (log) @@ -3855,7 +3855,7 @@ ProcessGDBRemote::AsyncThread (void *arg) { if (log) log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp)...", __FUNCTION__, arg, process->GetID()); - if (process->m_async_listener.WaitForEvent (NULL, event_sp)) + if (process->m_async_listener_sp->WaitForEvent (NULL, event_sp)) { const uint32_t event_type = event_sp->GetType(); if (event_sp->BroadcasterIs (&process->m_async_broadcaster)) diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h index 70633e71307..5f028229eed 100644 --- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h +++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h @@ -45,13 +45,13 @@ class ThreadGDBRemote; class ProcessGDBRemote : public Process { public: - ProcessGDBRemote(lldb::TargetSP target_sp, Listener &listener); + ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp); ~ProcessGDBRemote() override; static lldb::ProcessSP CreateInstance (lldb::TargetSP target_sp, - Listener &listener, + lldb::ListenerSP listener_sp, const FileSpec *crash_file_path); static void @@ -282,7 +282,7 @@ protected: Mutex m_last_stop_packet_mutex; GDBRemoteDynamicRegisterInfo m_register_info; Broadcaster m_async_broadcaster; - Listener m_async_listener; + lldb::ListenerSP m_async_listener_sp; HostThread m_async_thread; Mutex m_async_thread_state_mutex; typedef std::vector<lldb::tid_t> tid_collection; diff --git a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp index 43b7418b992..69006b2bdad 100644 --- a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp +++ b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp @@ -65,7 +65,7 @@ ProcessMachCore::Terminate() lldb::ProcessSP -ProcessMachCore::CreateInstance (lldb::TargetSP target_sp, Listener &listener, const FileSpec *crash_file) +ProcessMachCore::CreateInstance (lldb::TargetSP target_sp, ListenerSP listener_sp, const FileSpec *crash_file) { lldb::ProcessSP process_sp; if (crash_file) @@ -81,7 +81,7 @@ ProcessMachCore::CreateInstance (lldb::TargetSP target_sp, Listener &listener, c if (ObjectFileMachO::ParseHeader(data, &data_offset, mach_header)) { if (mach_header.filetype == llvm::MachO::MH_CORE) - process_sp.reset(new ProcessMachCore (target_sp, listener, *crash_file)); + process_sp.reset(new ProcessMachCore (target_sp, listener_sp, *crash_file)); } } @@ -122,8 +122,8 @@ ProcessMachCore::CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_nam //---------------------------------------------------------------------- // ProcessMachCore constructor //---------------------------------------------------------------------- -ProcessMachCore::ProcessMachCore(lldb::TargetSP target_sp, Listener &listener, const FileSpec &core_file) : - Process (target_sp, listener), +ProcessMachCore::ProcessMachCore(lldb::TargetSP target_sp, ListenerSP listener_sp, const FileSpec &core_file) : + Process (target_sp, listener_sp), m_core_aranges (), m_core_module_sp (), m_core_file (core_file), diff --git a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h index 2de0b772370..7b5b6adae85 100644 --- a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h +++ b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h @@ -30,14 +30,14 @@ public: // Constructors and Destructors //------------------------------------------------------------------ ProcessMachCore(lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener, const lldb_private::FileSpec &core_file); ~ProcessMachCore() override; static lldb::ProcessSP CreateInstance (lldb::TargetSP target_sp, - lldb_private::Listener &listener, + lldb::ListenerSP listener, const lldb_private::FileSpec *crash_file_path); static void diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp index f9befad1986..d138d4ae8e2 100644 --- a/lldb/source/Target/Process.cpp +++ b/lldb/source/Target/Process.cpp @@ -657,7 +657,7 @@ 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; @@ -669,7 +669,7 @@ Process::FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, Listener 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)) @@ -685,7 +685,7 @@ Process::FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, Listener { 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)) @@ -708,23 +708,23 @@ 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) : +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()), Process::GetStaticBroadcasterClass().AsCString()), + 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 ("lldb.process.internal_state_listener"), + m_private_state_listener_sp (Listener::MakeListener("lldb.process.internal_state_listener")), m_private_state_control_wait(), m_mod_id (), m_process_unique_id(0), @@ -742,7 +742,7 @@ Process::Process(lldb::TargetSP target_sp, Listener &listener, const UnixSignals m_queue_list_stop_id (0), m_notifications (), m_image_tokens (), - m_listener (listener), + m_listener_sp (listener_sp), m_breakpoint_site_list (), m_dynamic_checkers_ap (), m_unix_signals_sp (unix_signals_sp), @@ -792,18 +792,18 @@ Process::Process(lldb::TargetSP target_sp, Listener &listener, const UnixSignals m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlPause , "control-pause" ); m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlResume, "control-resume"); - listener.StartListeningForEvents (this, + m_listener_sp->StartListeningForEvents (this, eBroadcastBitStateChanged | eBroadcastBitInterrupt | eBroadcastBitSTDOUT | eBroadcastBitSTDERR | eBroadcastBitProfileData); - m_private_state_listener.StartListeningForEvents(&m_private_state_broadcaster, + m_private_state_listener_sp->StartListeningForEvents(&m_private_state_broadcaster, eBroadcastBitStateChanged | eBroadcastBitInterrupt); - m_private_state_listener.StartListeningForEvents(&m_private_state_control_broadcaster, + m_private_state_listener_sp->StartListeningForEvents(&m_private_state_control_broadcaster, eBroadcastInternalStateControlStop | eBroadcastInternalStateControlPause | eBroadcastInternalStateControlResume); @@ -904,7 +904,7 @@ Process::Finalize() //#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(); @@ -913,7 +913,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 @@ -970,7 +970,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; @@ -997,7 +997,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) { @@ -1026,7 +1026,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; } @@ -1034,11 +1034,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 != nullptr; + bool pop_process_io_handler = (hijack_listener_sp.get() != nullptr); Process::HandleProcessStateChangedEvent (event_sp, stream, pop_process_io_handler); switch (state) @@ -1049,7 +1049,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: @@ -1059,7 +1059,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; } @@ -1295,11 +1295,11 @@ Process::WaitForState(const TimeValue *timeout, } bool -Process::HijackProcessEvents (Listener *listener) +Process::HijackProcessEvents (ListenerSP listener_sp) { - if (listener != nullptr) + if (listener_sp) { - return HijackBroadcaster(listener, eBroadcastBitStateChanged | eBroadcastBitInterrupt); + return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged | eBroadcastBitInterrupt); } else return false; @@ -1312,7 +1312,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)); @@ -1320,15 +1320,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 == nullptr) - 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()); @@ -1352,7 +1352,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) { @@ -1381,7 +1381,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)) @@ -1408,9 +1408,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 @@ -1690,7 +1690,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; @@ -1763,13 +1764,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(nullptr, nullptr, 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)); @@ -3065,8 +3066,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 (); @@ -3091,7 +3092,7 @@ Process::LoadCore () // Wait indefinitely for a stopped event since we just posted one above... lldb::EventSP event_sp; - listener.WaitForEvent(nullptr, event_sp); + listener_sp->WaitForEvent (nullptr, event_sp); StateType state = ProcessEventData::GetStateFromEvent(event_sp.get()); if (!StateIsStoppedState (state, false)) @@ -3216,10 +3217,13 @@ Process::AttachCompletionHandler::GetExitString () return m_exit_string.c_str(); } -Listener & +ListenerSP ProcessAttachInfo::GetListenerForProcess (Debugger &debugger) { - return (m_listener_sp ? *m_listener_sp : debugger.GetListener()); + if (m_listener_sp) + return m_listener_sp; + else + return debugger.GetListener(); } Error @@ -3599,8 +3603,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; @@ -3620,7 +3624,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(); @@ -3645,8 +3649,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(); @@ -3654,7 +3658,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(); @@ -5323,7 +5327,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; @@ -5334,7 +5338,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) { @@ -5424,7 +5428,7 @@ 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(); + Event *other_events = listener_sp->PeekAtNextEvent(); if (other_events != nullptr) { errors.Printf("Calling RunThreadPlan with pending events on the queue."); @@ -5483,7 +5487,7 @@ 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) @@ -5605,7 +5609,7 @@ 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) { @@ -5805,7 +5809,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) { diff --git a/lldb/source/Target/ProcessLaunchInfo.cpp b/lldb/source/Target/ProcessLaunchInfo.cpp index 310203672e7..c9c53e9d2d7 100644 --- a/lldb/source/Target/ProcessLaunchInfo.cpp +++ b/lldb/source/Target/ProcessLaunchInfo.cpp @@ -517,11 +517,11 @@ ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell (Error &error, return false; } -Listener & +ListenerSP ProcessLaunchInfo::GetListenerForProcess (Debugger &debugger) { if (m_listener_sp) - return *m_listener_sp; + return m_listener_sp; else return debugger.GetListener(); } diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp index 7455c2035d0..acb84e5d174 100644 --- a/lldb/source/Target/Target.cpp +++ b/lldb/source/Target/Target.cpp @@ -70,7 +70,7 @@ Target::GetStaticBroadcasterClass () Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target) : TargetProperties (this), - Broadcaster (&debugger, Target::GetStaticBroadcasterClass().AsCString()), + Broadcaster (debugger.GetBroadcasterManager(), Target::GetStaticBroadcasterClass().AsCString()), ExecutionContextScope (), m_debugger (debugger), m_platform_sp (platform_sp), @@ -194,10 +194,10 @@ Target::DeleteCurrentProcess () } const lldb::ProcessSP & -Target::CreateProcess (Listener &listener, const char *plugin_name, const FileSpec *crash_file) +Target::CreateProcess (ListenerSP listener_sp, const char *plugin_name, const FileSpec *crash_file) { DeleteCurrentProcess (); - m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name, listener, crash_file); + m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name, listener_sp, crash_file); return m_process_sp; } @@ -3072,12 +3072,12 @@ Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream) ListenerSP hijack_listener_sp (launch_info.GetHijackListener()); if (!hijack_listener_sp) { - hijack_listener_sp.reset(new Listener("lldb.Target.Launch.hijack")); + hijack_listener_sp = Listener::MakeListener("lldb.Target.Launch.hijack"); launch_info.SetHijackListener(hijack_listener_sp); - m_process_sp->HijackProcessEvents(hijack_listener_sp.get()); + m_process_sp->HijackProcessEvents(hijack_listener_sp); } - StateType state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, false, hijack_listener_sp.get(), nullptr); + StateType state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, false, hijack_listener_sp, nullptr); if (state == eStateStopped) { @@ -3088,7 +3088,7 @@ Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream) error = m_process_sp->PrivateResume(); if (error.Success()) { - state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, true, hijack_listener_sp.get(), stream); + state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, true, hijack_listener_sp, stream); const bool must_be_alive = false; // eStateExited is ok, so this must be false if (!StateIsStoppedState(state, must_be_alive)) { @@ -3182,7 +3182,7 @@ Target::Attach (ProcessAttachInfo &attach_info, Stream *stream) const bool async = attach_info.GetAsync(); if (!async) { - hijack_listener_sp.reset (new Listener ("lldb.Target.Attach.attach.hijack")); + hijack_listener_sp = Listener::MakeListener("lldb.Target.Attach.attach.hijack"); attach_info.SetHijackListener (hijack_listener_sp); } @@ -3205,7 +3205,7 @@ Target::Attach (ProcessAttachInfo &attach_info, Stream *stream) } } if (hijack_listener_sp) - process_sp->HijackProcessEvents (hijack_listener_sp.get ()); + process_sp->HijackProcessEvents (hijack_listener_sp); error = process_sp->Attach (attach_info); } @@ -3217,7 +3217,7 @@ Target::Attach (ProcessAttachInfo &attach_info, Stream *stream) } else { - state = process_sp->WaitForProcessToStop (nullptr, nullptr, false, attach_info.GetHijackListener ().get (), stream); + state = process_sp->WaitForProcessToStop (nullptr, nullptr, false, attach_info.GetHijackListener(), stream); process_sp->RestoreProcessEvents (); if (state != eStateStopped) diff --git a/lldb/source/Target/TargetList.cpp b/lldb/source/Target/TargetList.cpp index ffec758ac21..5f1a4399717 100644 --- a/lldb/source/Target/TargetList.cpp +++ b/lldb/source/Target/TargetList.cpp @@ -43,7 +43,7 @@ TargetList::GetStaticBroadcasterClass () // TargetList constructor //---------------------------------------------------------------------- TargetList::TargetList(Debugger &debugger) : - Broadcaster(&debugger, TargetList::GetStaticBroadcasterClass().AsCString()), + Broadcaster(debugger.GetBroadcasterManager(), TargetList::GetStaticBroadcasterClass().AsCString()), m_target_list(), m_target_list_mutex (Mutex::eMutexTypeRecursive), m_selected_target_idx (0) diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp index fd3df8f4eb1..b4550940957 100644 --- a/lldb/source/Target/Thread.cpp +++ b/lldb/source/Target/Thread.cpp @@ -274,7 +274,7 @@ Thread::GetStaticBroadcasterClass () Thread::Thread (Process &process, lldb::tid_t tid, bool use_invalid_index_id) : ThreadProperties (false), UserID (tid), - Broadcaster(&process.GetTarget().GetDebugger(), Thread::GetStaticBroadcasterClass().AsCString()), + Broadcaster(process.GetTarget().GetDebugger().GetBroadcasterManager(), Thread::GetStaticBroadcasterClass().AsCString()), m_process_wp (process.shared_from_this()), m_stop_info_sp (), m_stop_info_stop_id (0), |
