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