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