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

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