contrib/llvm/tools/lldb/source/Core/Broadcaster.cpp

   1 //===-- Broadcaster.cpp -----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/Broadcaster.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Core/Log.h"
  17 #include "lldb/Core/Event.h"
  18 #include "lldb/Core/StreamString.h"
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22
  23 Broadcaster::Broadcaster (BroadcasterManager *manager, const char *name) :
  24     m_broadcaster_name (name),
  25     m_listeners (),
  26     m_listeners_mutex (Mutex::eMutexTypeRecursive),
  27     m_hijacking_listeners(),
  28     m_hijacking_masks(),
  29     m_manager (manager)
  30 {
  31     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
  32     if (log)
  33         log->Printf ("%p Broadcaster::Broadcaster(\"%s\")",
  34                      static_cast<void*>(this), m_broadcaster_name.AsCString());
  35 }
  36
  37 Broadcaster::~Broadcaster()
  38 {
  39     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
  40     if (log)
  41         log->Printf ("%p Broadcaster::~Broadcaster(\"%s\")",
  42                      static_cast<void*>(this), m_broadcaster_name.AsCString());
  43
  44     Clear();
  45 }
  46
  47 void
  48 Broadcaster::CheckInWithManager ()
  49 {
  50     if (m_manager != NULL)
  51     {
  52         m_manager->SignUpListenersForBroadcaster(*this);
  53     }
  54 }
  55
  56 void
  57 Broadcaster::Clear()
  58 {
  59     Mutex::Locker listeners_locker(m_listeners_mutex);
  60
  61     // Make sure the listener forgets about this broadcaster. We do
  62     // this in the broadcaster in case the broadcaster object initiates
  63     // the removal.
  64
  65     collection::iterator pos, end = m_listeners.end();
  66     for (pos = m_listeners.begin(); pos != end; ++pos)
  67         pos->first->BroadcasterWillDestruct (this);
  68
  69     m_listeners.clear();
  70 }
  71 const ConstString &
  72 Broadcaster::GetBroadcasterName ()
  73 {
  74     return m_broadcaster_name;
  75 }
  76
  77 bool
  78 Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const
  79 {
  80     uint32_t num_names_added = 0;
  81     if (event_mask && !m_event_names.empty())
  82     {
  83         event_names_map::const_iterator end = m_event_names.end();
  84         for (uint32_t bit=1u, mask=event_mask; mask != 0 && bit != 0; bit <<= 1, mask >>= 1)
  85         {
  86             if (mask & 1)
  87             {
  88                 event_names_map::const_iterator pos = m_event_names.find(bit);
  89                 if (pos != end)
  90                 {
  91                     if (num_names_added > 0)
  92                         s.PutCString(", ");
  93
  94                     if (prefix_with_broadcaster_name)
  95                     {
  96                         s.PutCString (m_broadcaster_name.GetCString());
  97                         s.PutChar('.');
  98                     }
  99                     s.PutCString(pos->second.c_str());
 100                     ++num_names_added;
 101                 }
 102             }
 103         }
 104     }
 105     return num_names_added > 0;
 106 }
 107
 108 void
 109 Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events)
 110 {
 111
 112 }
 113
 114 uint32_t
 115 Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
 116 {
 117     if (listener == NULL)
 118         return 0;
 119
 120     Mutex::Locker locker(m_listeners_mutex);
 121     collection::iterator pos, end = m_listeners.end();
 122
 123     collection::iterator existing_pos = end;
 124     // See if we already have this listener, and if so, update its mask
 125     uint32_t taken_event_types = 0;
 126     for (pos = m_listeners.begin(); pos != end; ++pos)
 127     {
 128         if (pos->first == listener)
 129             existing_pos = pos;
 130     // For now don't descriminate on who gets what
 131     // FIXME: Implement "unique listener for this bit" mask
 132     //  taken_event_types |= pos->second;
 133     }
 134
 135     // Each event bit in a Broadcaster object can only be used
 136     // by one listener
 137     uint32_t available_event_types = ~taken_event_types & event_mask;
 138
 139     if (available_event_types)
 140     {
 141         // If we didn't find our listener, add it
 142         if (existing_pos == end)
 143         {
 144             // Grant a new listener the available event bits
 145             m_listeners.push_back(std::make_pair(listener, available_event_types));
 146         }
 147         else
 148         {
 149             // Grant the existing listener the available event bits
 150             existing_pos->second |= available_event_types;
 151         }
 152
 153         // Individual broadcasters decide whether they have outstanding data when a
 154         // listener attaches, and insert it into the listener with this method.
 155
 156         AddInitialEventsToListener (listener, available_event_types);
 157     }
 158
 159     // Return the event bits that were granted to the listener
 160     return available_event_types;
 161 }
 162
 163 bool
 164 Broadcaster::EventTypeHasListeners (uint32_t event_type)
 165 {
 166     Mutex::Locker locker (m_listeners_mutex);
 167
 168     if (m_hijacking_listeners.size() > 0 && event_type & m_hijacking_masks.back())
 169         return true;
 170
 171     if (m_listeners.empty())
 172         return false;
 173
 174     collection::iterator pos, end = m_listeners.end();
 175     for (pos = m_listeners.begin(); pos != end; ++pos)
 176     {
 177         if (pos->second & event_type)
 178             return true;
 179     }
 180     return false;
 181 }
 182
 183 bool
 184 Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask)
 185 {
 186     Mutex::Locker locker(m_listeners_mutex);
 187     collection::iterator pos, end = m_listeners.end();
 188     // See if we already have this listener, and if so, update its mask
 189     for (pos = m_listeners.begin(); pos != end; ++pos)
 190     {
 191         if (pos->first == listener)
 192         {
 193             // Relinquish all event bits in "event_mask"
 194             pos->second &= ~event_mask;
 195             // If all bits have been relinquished then remove this listener
 196             if (pos->second == 0)
 197                 m_listeners.erase (pos);
 198             return true;
 199         }
 200     }
 201     return false;
 202 }
 203
 204 void
 205 Broadcaster::BroadcastEvent (EventSP &event_sp)
 206 {
 207     return PrivateBroadcastEvent (event_sp, false);
 208 }
 209
 210 void
 211 Broadcaster::BroadcastEventIfUnique (EventSP &event_sp)
 212 {
 213     return PrivateBroadcastEvent (event_sp, true);
 214 }
 215
 216 void
 217 Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
 218 {
 219     // Can't add a NULL event...
 220     if (event_sp.get() == NULL)
 221         return;
 222
 223     // Update the broadcaster on this event
 224     event_sp->SetBroadcaster (this);
 225
 226     const uint32_t event_type = event_sp->GetType();
 227
 228     Mutex::Locker event_types_locker(m_listeners_mutex);
 229
 230     Listener *hijacking_listener = NULL;
 231     if (!m_hijacking_listeners.empty())
 232     {
 233         assert (!m_hijacking_masks.empty());
 234         hijacking_listener = m_hijacking_listeners.back();
 235         if ((event_type & m_hijacking_masks.back()) == 0)
 236             hijacking_listener = NULL;
 237     }
 238
 239     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
 240     if (log)
 241     {
 242         StreamString event_description;
 243         event_sp->Dump  (&event_description);
 244         log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p",
 245                      static_cast<void*>(this), m_broadcaster_name.AsCString(""),
 246                      event_description.GetData(), unique,
 247                      static_cast<void*>(hijacking_listener));
 248     }
 249
 250     if (hijacking_listener)
 251     {
 252         if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type))
 253             return;
 254         hijacking_listener->AddEvent (event_sp);
 255     }
 256     else
 257     {
 258         collection::iterator pos, end = m_listeners.end();
 259
 260
 261         // Iterate through all listener/mask pairs
 262         for (pos = m_listeners.begin(); pos != end; ++pos)
 263         {
 264             // If the listener's mask matches any bits that we just set, then
 265             // put the new event on its event queue.
 266             if (event_type & pos->second)
 267             {
 268                 if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type))
 269                     continue;
 270                 pos->first->AddEvent (event_sp);
 271             }
 272         }
 273     }
 274 }
 275
 276 void
 277 Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data)
 278 {
 279     EventSP event_sp (new Event (event_type, event_data));
 280     PrivateBroadcastEvent (event_sp, false);
 281 }
 282
 283 void
 284 Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data)
 285 {
 286     EventSP event_sp (new Event (event_type, event_data));
 287     PrivateBroadcastEvent (event_sp, true);
 288 }
 289
 290 bool
 291 Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask)
 292 {
 293     Mutex::Locker event_types_locker(m_listeners_mutex);
 294
 295     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
 296     if (log)
 297         log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
 298                      static_cast<void*>(this), m_broadcaster_name.AsCString(""),
 299                      listener->m_name.c_str(), static_cast<void*>(listener));
 300     m_hijacking_listeners.push_back(listener);
 301     m_hijacking_masks.push_back(event_mask);
 302     return true;
 303 }
 304
 305 bool
 306 Broadcaster::IsHijackedForEvent (uint32_t event_mask)
 307 {
 308     Mutex::Locker event_types_locker(m_listeners_mutex);
 309
 310     if (!m_hijacking_listeners.empty())
 311         return (event_mask & m_hijacking_masks.back()) != 0;
 312     return false;
 313 }
 314
 315 void
 316 Broadcaster::RestoreBroadcaster ()
 317 {
 318     Mutex::Locker event_types_locker(m_listeners_mutex);
 319
 320     if (!m_hijacking_listeners.empty())
 321     {
 322         Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
 323         if (log)
 324         {
 325             Listener *listener = m_hijacking_listeners.back();
 326             log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)",
 327                          static_cast<void*>(this),
 328                          m_broadcaster_name.AsCString(""),
 329                          listener->m_name.c_str(), static_cast<void*>(listener));
 330         }
 331         m_hijacking_listeners.pop_back();
 332     }
 333     if (!m_hijacking_masks.empty())
 334         m_hijacking_masks.pop_back();
 335 }
 336
 337 ConstString &
 338 Broadcaster::GetBroadcasterClass() const
 339 {
 340     static ConstString class_name ("lldb.anonymous");
 341     return class_name;
 342 }
 343
 344 BroadcastEventSpec::BroadcastEventSpec (const BroadcastEventSpec &rhs) :
 345     m_broadcaster_class (rhs.m_broadcaster_class),
 346     m_event_bits (rhs.m_event_bits)
 347 {
 348 }
 349
 350 bool
 351 BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const
 352 {
 353     if (GetBroadcasterClass() == rhs.GetBroadcasterClass())
 354     {
 355         return GetEventBits() < rhs.GetEventBits();
 356     }
 357     else
 358     {
 359         return GetBroadcasterClass() < rhs.GetBroadcasterClass();
 360     }
 361 }
 362
 363 const BroadcastEventSpec &
 364 BroadcastEventSpec::operator= (const BroadcastEventSpec &rhs)
 365 {
 366     m_broadcaster_class = rhs.m_broadcaster_class;
 367     m_event_bits = rhs.m_event_bits;
 368     return *this;
 369 }
 370
 371 BroadcasterManager::BroadcasterManager() :
 372     m_manager_mutex(Mutex::eMutexTypeRecursive)
 373 {
 374
 375 }
 376
 377 uint32_t
 378 BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
 379 {
 380     Mutex::Locker locker(m_manager_mutex);
 381
 382     collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
 383     uint32_t available_bits = event_spec.GetEventBits();
 384
 385     while (iter != end_iter
 386            && (iter = find_if (iter, end_iter, BroadcasterClassMatches(event_spec.GetBroadcasterClass()))) != end_iter)
 387     {
 388         available_bits &= ~((*iter).first.GetEventBits());
 389         iter++;
 390     }
 391
 392     if (available_bits != 0)
 393     {
 394         m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener));
 395         m_listeners.insert(&listener);
 396     }
 397
 398     return available_bits;
 399 }
 400
 401 bool
 402 BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
 403 {
 404     Mutex::Locker locker(m_manager_mutex);
 405     bool removed_some = false;
 406
 407     if (m_listeners.erase(&listener) == 0)
 408         return false;
 409
 410     ListenerMatchesAndSharedBits predicate (event_spec, listener);
 411     std::vector<BroadcastEventSpec> to_be_readded;
 412     uint32_t event_bits_to_remove = event_spec.GetEventBits();
 413
 414     // Go through the map and delete the exact matches, and build a list of matches that weren't exact to re-add:
 415     while (1)
 416     {
 417         collection::iterator iter, end_iter = m_event_map.end();
 418         iter = find_if (m_event_map.begin(), end_iter, predicate);
 419         if (iter == end_iter)
 420         {
 421             break;
 422         }
 423         else
 424         {
 425             uint32_t iter_event_bits = (*iter).first.GetEventBits();
 426             removed_some = true;
 427
 428             if (event_bits_to_remove != iter_event_bits)
 429             {
 430                 uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
 431                 to_be_readded.push_back(BroadcastEventSpec (event_spec.GetBroadcasterClass(), new_event_bits));
 432             }
 433             m_event_map.erase (iter);
 434         }
 435     }
 436
 437     // Okay now add back the bits that weren't completely removed:
 438     for (size_t i = 0; i < to_be_readded.size(); i++)
 439     {
 440         m_event_map.insert (event_listener_key (to_be_readded[i], &listener));
 441     }
 442
 443     return removed_some;
 444 }
 445
 446 Listener *
 447 BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
 448 {
 449     Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex)));
 450
 451     collection::const_iterator iter, end_iter = m_event_map.end();
 452     iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec));
 453     if (iter != end_iter)
 454         return (*iter).second;
 455     else
 456         return NULL;
 457 }
 458
 459 void
 460 BroadcasterManager::RemoveListener (Listener &listener)
 461 {
 462     Mutex::Locker locker(m_manager_mutex);
 463     ListenerMatches predicate (listener);
 464
 465
 466     if (m_listeners.erase (&listener) == 0)
 467         return;
 468
 469     while (1)
 470     {
 471         collection::iterator iter, end_iter = m_event_map.end();
 472         iter = find_if (m_event_map.begin(), end_iter, predicate);
 473         if (iter == end_iter)
 474             break;
 475         else
 476             m_event_map.erase(iter);
 477     }
 478 }
 479
 480 void
 481 BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster)
 482 {
 483     Mutex::Locker locker(m_manager_mutex);
 484
 485     collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
 486
 487     while (iter != end_iter
 488            && (iter = find_if (iter, end_iter, BroadcasterClassMatches(broadcaster.GetBroadcasterClass()))) != end_iter)
 489     {
 490         (*iter).second->StartListeningForEvents (&broadcaster, (*iter).first.GetEventBits());
 491         iter++;
 492     }
 493 }
 494
 495 void
 496 BroadcasterManager::Clear ()
 497 {
 498     Mutex::Locker locker(m_manager_mutex);
 499     listener_collection::iterator end_iter = m_listeners.end();
 500
 501     for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)
 502         (*iter)->BroadcasterManagerWillDestruct(this);
 503     m_listeners.clear();
 504     m_event_map.clear();
 505
 506 }