1 //===-- Listener.cpp --------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/Listener.h"
14 // Other libraries and framework includes
16 #include "lldb/Core/Broadcaster.h"
17 #include "lldb/Core/Log.h"
18 #include "lldb/Core/StreamString.h"
19 #include "lldb/Core/Event.h"
20 #include "lldb/Host/TimeValue.h"
21 #include "lldb/lldb-private-log.h"
25 using namespace lldb_private;
27 Listener::Listener(const char *name) :
30 m_broadcasters_mutex (Mutex::eMutexTypeRecursive),
32 m_events_mutex (Mutex::eMutexTypeRecursive),
35 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
37 log->Printf ("%p Listener::Listener('%s')",
38 static_cast<void*>(this), m_name.c_str());
43 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
44 Mutex::Locker locker (m_broadcasters_mutex);
46 size_t num_managers = m_broadcaster_managers.size();
48 for (size_t i = 0; i < num_managers; i++)
49 m_broadcaster_managers[i]->RemoveListener(*this);
52 log->Printf ("%p Listener::~Listener('%s')",
53 static_cast<void*>(this), m_name.c_str());
60 Mutex::Locker locker(m_broadcasters_mutex);
61 broadcaster_collection::iterator pos, end = m_broadcasters.end();
62 for (pos = m_broadcasters.begin(); pos != end; ++pos)
63 pos->first->RemoveListener (this, pos->second.event_mask);
64 m_broadcasters.clear();
65 m_cond_wait.SetValue (false, eBroadcastNever);
66 m_broadcasters.clear();
67 Mutex::Locker event_locker(m_events_mutex);
72 Listener::StartListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask)
77 // Tell the broadcaster to add this object as a listener
79 Mutex::Locker locker(m_broadcasters_mutex);
80 m_broadcasters.insert(std::make_pair(broadcaster, BroadcasterInfo(event_mask)));
83 uint32_t acquired_mask = broadcaster->AddListener (this, event_mask);
85 if (event_mask != acquired_mask)
89 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
91 log->Printf ("%p Listener::StartListeningForEvents (broadcaster = %p, mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
92 static_cast<void*>(this),
93 static_cast<void*>(broadcaster), event_mask,
94 acquired_mask, m_name.c_str());
103 Listener::StartListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask, HandleBroadcastCallback callback, void *callback_user_data)
107 // Scope for "locker"
108 // Tell the broadcaster to add this object as a listener
110 Mutex::Locker locker(m_broadcasters_mutex);
111 m_broadcasters.insert(std::make_pair(broadcaster, BroadcasterInfo(event_mask, callback, callback_user_data)));
114 uint32_t acquired_mask = broadcaster->AddListener (this, event_mask);
116 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
119 void **pointer = reinterpret_cast<void**>(&callback);
120 log->Printf ("%p Listener::StartListeningForEvents (broadcaster = %p, mask = 0x%8.8x, callback = %p, user_data = %p) acquired_mask = 0x%8.8x for %s",
121 static_cast<void*>(this),
122 static_cast<void*>(broadcaster), event_mask, *pointer,
123 static_cast<void*>(callback_user_data), acquired_mask,
127 return acquired_mask;
133 Listener::StopListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask)
137 // Scope for "locker"
139 Mutex::Locker locker(m_broadcasters_mutex);
140 m_broadcasters.erase (broadcaster);
142 // Remove the broadcaster from our set of broadcasters
143 return broadcaster->RemoveListener (this, event_mask);
149 // Called when a Broadcaster is in its destructor. We need to remove all
150 // knowledge of this broadcaster and any events that it may have queued up
152 Listener::BroadcasterWillDestruct (Broadcaster *broadcaster)
154 // Scope for "broadcasters_locker"
156 Mutex::Locker broadcasters_locker(m_broadcasters_mutex);
157 m_broadcasters.erase (broadcaster);
160 // Scope for "event_locker"
162 Mutex::Locker event_locker(m_events_mutex);
163 // Remove all events for this broadcaster object.
164 event_collection::iterator pos = m_events.begin();
165 while (pos != m_events.end())
167 if ((*pos)->GetBroadcaster() == broadcaster)
168 pos = m_events.erase(pos);
173 if (m_events.empty())
174 m_cond_wait.SetValue (false, eBroadcastNever);
180 Listener::BroadcasterManagerWillDestruct (BroadcasterManager *manager)
182 // Just need to remove this broadcast manager from the list of managers:
183 broadcaster_manager_collection::iterator iter, end_iter = m_broadcaster_managers.end();
184 iter = find(m_broadcaster_managers.begin(), end_iter, manager);
185 if (iter != end_iter)
186 m_broadcaster_managers.erase (iter);
190 Listener::AddEvent (EventSP &event_sp)
192 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
194 log->Printf ("%p Listener('%s')::AddEvent (event_sp = {%p})",
195 static_cast<void*>(this), m_name.c_str(),
196 static_cast<void*>(event_sp.get()));
198 // Scope for "locker"
200 Mutex::Locker locker(m_events_mutex);
201 m_events.push_back (event_sp);
203 m_cond_wait.SetValue (true, eBroadcastAlways);
206 class EventBroadcasterMatches
209 EventBroadcasterMatches (Broadcaster *broadcaster) :
210 m_broadcaster (broadcaster) {
213 bool operator() (const EventSP &event_sp) const
215 if (event_sp->BroadcasterIs(m_broadcaster))
222 Broadcaster *m_broadcaster;
229 EventMatcher (Broadcaster *broadcaster, const ConstString *broadcaster_names, uint32_t num_broadcaster_names, uint32_t event_type_mask) :
230 m_broadcaster (broadcaster),
231 m_broadcaster_names (broadcaster_names),
232 m_num_broadcaster_names (num_broadcaster_names),
233 m_event_type_mask (event_type_mask)
237 bool operator() (const EventSP &event_sp) const
239 if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
242 if (m_broadcaster_names)
244 bool found_source = false;
245 const ConstString &event_broadcaster_name = event_sp->GetBroadcaster()->GetBroadcasterName();
246 for (uint32_t i=0; i<m_num_broadcaster_names; ++i)
248 if (m_broadcaster_names[i] == event_broadcaster_name)
258 if (m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType())
264 Broadcaster *m_broadcaster;
265 const ConstString *m_broadcaster_names;
266 const uint32_t m_num_broadcaster_names;
267 const uint32_t m_event_type_mask;
272 Listener::FindNextEventInternal
274 Broadcaster *broadcaster, // NULL for any broadcaster
275 const ConstString *broadcaster_names, // NULL for any event
276 uint32_t num_broadcaster_names,
277 uint32_t event_type_mask,
281 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
283 Mutex::Locker lock(m_events_mutex);
285 if (m_events.empty())
289 Listener::event_collection::iterator pos = m_events.end();
291 if (broadcaster == NULL && broadcaster_names == NULL && event_type_mask == 0)
293 pos = m_events.begin();
297 pos = std::find_if (m_events.begin(), m_events.end(), EventMatcher (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask));
300 if (pos != m_events.end())
305 log->Printf ("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, broadcaster_names=%p[%u], event_type_mask=0x%8.8x, remove=%i) event %p",
306 static_cast<void*>(this), GetName(),
307 static_cast<void*>(broadcaster),
308 static_cast<const void*>(broadcaster_names),
309 num_broadcaster_names, event_type_mask, remove,
310 static_cast<void*>(event_sp.get()));
316 if (m_events.empty())
317 m_cond_wait.SetValue (false, eBroadcastNever);
320 // Unlock the event queue here. We've removed this event and are about to return
321 // it so it should be okay to get the next event off the queue here - and it might
322 // be useful to do that in the "DoOnRemoval".
325 // Don't call DoOnRemoval if you aren't removing the event...
327 event_sp->DoOnRemoval();
337 Listener::PeekAtNextEvent ()
340 if (FindNextEventInternal (NULL, NULL, 0, 0, event_sp, false))
341 return event_sp.get();
346 Listener::PeekAtNextEventForBroadcaster (Broadcaster *broadcaster)
349 if (FindNextEventInternal (broadcaster, NULL, 0, 0, event_sp, false))
350 return event_sp.get();
355 Listener::PeekAtNextEventForBroadcasterWithType (Broadcaster *broadcaster, uint32_t event_type_mask)
358 if (FindNextEventInternal (broadcaster, NULL, 0, event_type_mask, event_sp, false))
359 return event_sp.get();
365 Listener::GetNextEventInternal
367 Broadcaster *broadcaster, // NULL for any broadcaster
368 const ConstString *broadcaster_names, // NULL for any event
369 uint32_t num_broadcaster_names,
370 uint32_t event_type_mask,
374 return FindNextEventInternal (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask, event_sp, true);
378 Listener::GetNextEvent (EventSP &event_sp)
380 return GetNextEventInternal (NULL, NULL, 0, 0, event_sp);
385 Listener::GetNextEventForBroadcaster (Broadcaster *broadcaster, EventSP &event_sp)
387 return GetNextEventInternal (broadcaster, NULL, 0, 0, event_sp);
391 Listener::GetNextEventForBroadcasterWithType (Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp)
393 return GetNextEventInternal (broadcaster, NULL, 0, event_type_mask, event_sp);
398 Listener::WaitForEventsInternal
400 const TimeValue *timeout,
401 Broadcaster *broadcaster, // NULL for any broadcaster
402 const ConstString *broadcaster_names, // NULL for any event
403 uint32_t num_broadcaster_names,
404 uint32_t event_type_mask,
408 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
409 bool timed_out = false;
412 log->Printf ("%p Listener::WaitForEventsInternal (timeout = { %p }) for %s",
413 static_cast<void*>(this), static_cast<const void*>(timeout),
418 // Note, we don't want to lock the m_events_mutex in the call to GetNextEventInternal, since the DoOnRemoval
419 // code might require that new events be serviced. For instance, the Breakpoint Command's
420 if (GetNextEventInternal (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask, event_sp))
424 // Reset condition value to false, so we can wait for new events to be
425 // added that might meet our current filter
426 // But first poll for any new event that might satisfy our condition, and if so consume it,
429 Mutex::Locker event_locker(m_events_mutex);
430 const bool remove = false;
431 if (FindNextEventInternal (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask, event_sp, remove))
434 m_cond_wait.SetValue (false, eBroadcastNever);
437 if (m_cond_wait.WaitForValueEqualTo (true, timeout, &timed_out))
442 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS);
444 log->Printf ("%p Listener::WaitForEventsInternal() timed out for %s",
445 static_cast<void*>(this), m_name.c_str());
450 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS);
452 log->Printf ("%p Listener::WaitForEventsInternal() unknown error for %s",
453 static_cast<void*>(this), m_name.c_str());
462 Listener::WaitForEventForBroadcasterWithType
464 const TimeValue *timeout,
465 Broadcaster *broadcaster,
466 uint32_t event_type_mask,
470 return WaitForEventsInternal (timeout, broadcaster, NULL, 0, event_type_mask, event_sp);
474 Listener::WaitForEventForBroadcaster
476 const TimeValue *timeout,
477 Broadcaster *broadcaster,
481 return WaitForEventsInternal (timeout, broadcaster, NULL, 0, 0, event_sp);
485 Listener::WaitForEvent (const TimeValue *timeout, EventSP &event_sp)
487 return WaitForEventsInternal (timeout, NULL, NULL, 0, 0, event_sp);
490 //Listener::broadcaster_collection::iterator
491 //Listener::FindBroadcasterWithMask (Broadcaster *broadcaster, uint32_t event_mask, bool exact)
493 // broadcaster_collection::iterator pos;
494 // broadcaster_collection::iterator end = m_broadcasters.end();
495 // for (pos = m_broadcasters.find (broadcaster);
496 // pos != end && pos->first == broadcaster;
501 // if ((event_mask & pos->second.event_mask) == event_mask)
506 // if (event_mask & pos->second.event_mask)
514 Listener::HandleBroadcastEvent (EventSP &event_sp)
516 size_t num_handled = 0;
517 Mutex::Locker locker(m_broadcasters_mutex);
518 Broadcaster *broadcaster = event_sp->GetBroadcaster();
519 broadcaster_collection::iterator pos;
520 broadcaster_collection::iterator end = m_broadcasters.end();
521 for (pos = m_broadcasters.find (broadcaster);
522 pos != end && pos->first == broadcaster;
525 BroadcasterInfo info = pos->second;
526 if (event_sp->GetType () & info.event_mask)
528 if (info.callback != NULL)
530 info.callback (event_sp, info.callback_user_data);
539 Listener::StartListeningForEventSpec (BroadcasterManager &manager,
540 const BroadcastEventSpec &event_spec)
542 // The BroadcasterManager mutex must be locked before m_broadcasters_mutex
543 // to avoid violating the lock hierarchy (manager before broadcasters).
544 Mutex::Locker manager_locker(manager.m_manager_mutex);
545 Mutex::Locker locker(m_broadcasters_mutex);
547 uint32_t bits_acquired = manager.RegisterListenerForEvents(*this, event_spec);
549 m_broadcaster_managers.push_back(&manager);
551 return bits_acquired;
555 Listener::StopListeningForEventSpec (BroadcasterManager &manager,
556 const BroadcastEventSpec &event_spec)
558 Mutex::Locker locker(m_broadcasters_mutex);
559 return manager.UnregisterListenerForEvents (*this, event_spec);