diff options
Diffstat (limited to 'lldb/include')
| -rw-r--r-- | lldb/include/lldb/API/SBListener.h | 15 | ||||
| -rw-r--r-- | lldb/include/lldb/Core/Broadcaster.h | 301 | ||||
| -rw-r--r-- | lldb/include/lldb/Core/Debugger.h | 22 | ||||
| -rw-r--r-- | lldb/include/lldb/Core/Event.h | 19 | ||||
| -rw-r--r-- | lldb/include/lldb/Core/Listener.h | 24 | ||||
| -rw-r--r-- | lldb/include/lldb/Target/Process.h | 23 | ||||
| -rw-r--r-- | lldb/include/lldb/Target/ProcessLaunchInfo.h | 2 | ||||
| -rw-r--r-- | lldb/include/lldb/Target/Target.h | 2 | ||||
| -rw-r--r-- | lldb/include/lldb/lldb-forward.h | 2 | ||||
| -rw-r--r-- | lldb/include/lldb/lldb-private-interfaces.h | 2 |
10 files changed, 314 insertions, 98 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 |
