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

   1 //===-- Listener.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/Listener.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project 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"
  22 #include <algorithm>
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 Listener::Listener(const char *name) :
  28     m_name (name),
  29     m_broadcasters(),
  30     m_broadcasters_mutex (Mutex::eMutexTypeRecursive),
  31     m_events (),
  32     m_events_mutex (Mutex::eMutexTypeRecursive),
  33     m_cond_wait()
  34 {
  35     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
  36     if (log)
  37         log->Printf ("%p Listener::Listener('%s')", this, m_name.c_str());
  38 }
  39
  40 Listener::~Listener()
  41 {
  42     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
  43     Mutex::Locker locker (m_broadcasters_mutex);
  44
  45     size_t num_managers = m_broadcaster_managers.size();
  46
  47     for (size_t i = 0; i < num_managers; i++)
  48         m_broadcaster_managers[i]->RemoveListener(*this);
  49
  50     if (log)
  51         log->Printf ("%p Listener::~Listener('%s')", this, m_name.c_str());
  52     Clear();
  53 }
  54
  55 void
  56 Listener::Clear()
  57 {
  58     Mutex::Locker locker(m_broadcasters_mutex);
  59     broadcaster_collection::iterator pos, end = m_broadcasters.end();
  60     for (pos = m_broadcasters.begin(); pos != end; ++pos)
  61         pos->first->RemoveListener (this, pos->second.event_mask);
  62     m_broadcasters.clear();
  63     m_cond_wait.SetValue (false, eBroadcastNever);
  64     m_broadcasters.clear();
  65     Mutex::Locker event_locker(m_events_mutex);
  66     m_events.clear();
  67 }
  68
  69 uint32_t
  70 Listener::StartListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask)
  71 {
  72     if (broadcaster)
  73     {
  74         // Scope for "locker"
  75         // Tell the broadcaster to add this object as a listener
  76         {
  77             Mutex::Locker locker(m_broadcasters_mutex);
  78             m_broadcasters.insert(std::make_pair(broadcaster, BroadcasterInfo(event_mask)));
  79         }
  80
  81         uint32_t acquired_mask = broadcaster->AddListener (this, event_mask);
  82
  83         if (event_mask != acquired_mask)
  84         {
  85
  86         }
  87         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
  88         if (log)
  89             log->Printf ("%p Listener::StartListeningForEvents (broadcaster = %p, mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
  90                          this,
  91                          broadcaster,
  92                          event_mask,
  93                          acquired_mask,
  94                          m_name.c_str());
  95
  96         return acquired_mask;
  97
  98     }
  99     return 0;
 100 }
 101
 102 uint32_t
 103 Listener::StartListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask, HandleBroadcastCallback callback, void *callback_user_data)
 104 {
 105     if (broadcaster)
 106     {
 107         // Scope for "locker"
 108         // Tell the broadcaster to add this object as a listener
 109         {
 110             Mutex::Locker locker(m_broadcasters_mutex);
 111             m_broadcasters.insert(std::make_pair(broadcaster, BroadcasterInfo(event_mask, callback, callback_user_data)));
 112         }
 113
 114         uint32_t acquired_mask = broadcaster->AddListener (this, event_mask);
 115
 116         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
 117         if (log)
 118             log->Printf ("%p Listener::StartListeningForEvents (broadcaster = %p, mask = 0x%8.8x, callback = %p, user_data = %p) acquired_mask = 0x%8.8x for %s",
 119                         this, broadcaster, event_mask, callback, callback_user_data, acquired_mask, m_name.c_str());
 120
 121         return acquired_mask;
 122     }
 123     return 0;
 124 }
 125
 126 bool
 127 Listener::StopListeningForEvents (Broadcaster* broadcaster, uint32_t event_mask)
 128 {
 129     if (broadcaster)
 130     {
 131         // Scope for "locker"
 132         {
 133             Mutex::Locker locker(m_broadcasters_mutex);
 134             m_broadcasters.erase (broadcaster);
 135         }
 136         // Remove the broadcaster from our set of broadcasters
 137         return broadcaster->RemoveListener (this, event_mask);
 138     }
 139
 140     return false;
 141 }
 142
 143 // Called when a Broadcaster is in its destuctor. We need to remove all
 144 // knowledge of this broadcaster and any events that it may have queued up
 145 void
 146 Listener::BroadcasterWillDestruct (Broadcaster *broadcaster)
 147 {
 148     // Scope for "broadcasters_locker"
 149     {
 150         Mutex::Locker broadcasters_locker(m_broadcasters_mutex);
 151         m_broadcasters.erase (broadcaster);
 152     }
 153
 154     // Scope for "event_locker"
 155     {
 156         Mutex::Locker event_locker(m_events_mutex);
 157         // Remove all events for this broadcaster object.
 158         event_collection::iterator pos = m_events.begin();
 159         while (pos != m_events.end())
 160         {
 161             if ((*pos)->GetBroadcaster() == broadcaster)
 162                 pos = m_events.erase(pos);
 163             else
 164                 ++pos;
 165         }
 166
 167         if (m_events.empty())
 168             m_cond_wait.SetValue (false, eBroadcastNever);
 169
 170     }
 171 }
 172
 173 void
 174 Listener::BroadcasterManagerWillDestruct (BroadcasterManager *manager)
 175 {
 176     // Just need to remove this broadcast manager from the list of managers:
 177     broadcaster_manager_collection::iterator iter, end_iter = m_broadcaster_managers.end();
 178     iter = find(m_broadcaster_managers.begin(), end_iter, manager);
 179     if (iter != end_iter)
 180         m_broadcaster_managers.erase (iter);
 181 }
 182
 183 void
 184 Listener::AddEvent (EventSP &event_sp)
 185 {
 186     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
 187     if (log)
 188         log->Printf ("%p Listener('%s')::AddEvent (event_sp = {%p})", this, m_name.c_str(), event_sp.get());
 189
 190     // Scope for "locker"
 191     {
 192         Mutex::Locker locker(m_events_mutex);
 193         m_events.push_back (event_sp);
 194     }
 195     m_cond_wait.SetValue (true, eBroadcastAlways);
 196 }
 197
 198 class EventBroadcasterMatches
 199 {
 200 public:
 201     EventBroadcasterMatches (Broadcaster *broadcaster) :
 202         m_broadcaster (broadcaster)    {
 203     }
 204
 205     bool operator() (const EventSP &event_sp) const
 206     {
 207         if (event_sp->BroadcasterIs(m_broadcaster))
 208             return true;
 209         else
 210             return false;
 211     }
 212
 213 private:
 214     Broadcaster *m_broadcaster;
 215
 216 };
 217
 218 class EventMatcher
 219 {
 220 public:
 221     EventMatcher (Broadcaster *broadcaster, const ConstString *broadcaster_names, uint32_t num_broadcaster_names, uint32_t event_type_mask) :
 222         m_broadcaster (broadcaster),
 223         m_broadcaster_names (broadcaster_names),
 224         m_num_broadcaster_names (num_broadcaster_names),
 225         m_event_type_mask (event_type_mask)
 226     {
 227     }
 228
 229     bool operator() (const EventSP &event_sp) const
 230     {
 231         if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
 232             return false;
 233
 234         if (m_broadcaster_names)
 235         {
 236             bool found_source = false;
 237             const ConstString &event_broadcaster_name = event_sp->GetBroadcaster()->GetBroadcasterName();
 238             for (uint32_t i=0; i<m_num_broadcaster_names; ++i)
 239             {
 240                 if (m_broadcaster_names[i] == event_broadcaster_name)
 241                 {
 242                     found_source = true;
 243                     break;
 244                 }
 245             }
 246             if (!found_source)
 247                 return false;
 248         }
 249
 250         if (m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType())
 251             return true;
 252         return false;
 253     }
 254
 255 private:
 256     Broadcaster *m_broadcaster;
 257     const ConstString *m_broadcaster_names;
 258     const uint32_t m_num_broadcaster_names;
 259     const uint32_t m_event_type_mask;
 260 };
 261
 262
 263 bool
 264 Listener::FindNextEventInternal
 265 (
 266     Broadcaster *broadcaster,   // NULL for any broadcaster
 267     const ConstString *broadcaster_names, // NULL for any event
 268     uint32_t num_broadcaster_names,
 269     uint32_t event_type_mask,
 270     EventSP &event_sp,
 271     bool remove)
 272 {
 273     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
 274
 275     Mutex::Locker lock(m_events_mutex);
 276
 277     if (m_events.empty())
 278         return false;
 279
 280
 281     Listener::event_collection::iterator pos = m_events.end();
 282
 283     if (broadcaster == NULL && broadcaster_names == NULL && event_type_mask == 0)
 284     {
 285         pos = m_events.begin();
 286     }
 287     else
 288     {
 289         pos = std::find_if (m_events.begin(), m_events.end(), EventMatcher (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask));
 290     }
 291
 292     if (pos != m_events.end())
 293     {
 294         event_sp = *pos;
 295
 296         if (log)
 297             log->Printf ("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, broadcaster_names=%p[%u], event_type_mask=0x%8.8x, remove=%i) event %p",
 298                          this,
 299                          GetName(),
 300                          broadcaster,
 301                          broadcaster_names,
 302                          num_broadcaster_names,
 303                          event_type_mask,
 304                          remove,
 305                          event_sp.get());
 306
 307         if (remove)
 308         {
 309             m_events.erase(pos);
 310
 311             if (m_events.empty())
 312                 m_cond_wait.SetValue (false, eBroadcastNever);
 313         }
 314
 315         // Unlock the event queue here.  We've removed this event and are about to return
 316         // it so it should be okay to get the next event off the queue here - and it might
 317         // be useful to do that in the "DoOnRemoval".
 318         lock.Unlock();
 319
 320         // Don't call DoOnRemoval if you aren't removing the event...
 321         if (remove)
 322             event_sp->DoOnRemoval();
 323
 324         return true;
 325     }
 326
 327     event_sp.reset();
 328     return false;
 329 }
 330
 331 Event *
 332 Listener::PeekAtNextEvent ()
 333 {
 334     EventSP event_sp;
 335     if (FindNextEventInternal (NULL, NULL, 0, 0, event_sp, false))
 336         return event_sp.get();
 337     return NULL;
 338 }
 339
 340 Event *
 341 Listener::PeekAtNextEventForBroadcaster (Broadcaster *broadcaster)
 342 {
 343     EventSP event_sp;
 344     if (FindNextEventInternal (broadcaster, NULL, 0, 0, event_sp, false))
 345         return event_sp.get();
 346     return NULL;
 347 }
 348
 349 Event *
 350 Listener::PeekAtNextEventForBroadcasterWithType (Broadcaster *broadcaster, uint32_t event_type_mask)
 351 {
 352     EventSP event_sp;
 353     if (FindNextEventInternal (broadcaster, NULL, 0, event_type_mask, event_sp, false))
 354         return event_sp.get();
 355     return NULL;
 356 }
 357
 358
 359 bool
 360 Listener::GetNextEventInternal
 361 (
 362     Broadcaster *broadcaster,   // NULL for any broadcaster
 363     const ConstString *broadcaster_names, // NULL for any event
 364     uint32_t num_broadcaster_names,
 365     uint32_t event_type_mask,
 366     EventSP &event_sp
 367 )
 368 {
 369     return FindNextEventInternal (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask, event_sp, true);
 370 }
 371
 372 bool
 373 Listener::GetNextEvent (EventSP &event_sp)
 374 {
 375     return GetNextEventInternal (NULL, NULL, 0, 0, event_sp);
 376 }
 377
 378
 379 bool
 380 Listener::GetNextEventForBroadcaster (Broadcaster *broadcaster, EventSP &event_sp)
 381 {
 382     return GetNextEventInternal (broadcaster, NULL, 0, 0, event_sp);
 383 }
 384
 385 bool
 386 Listener::GetNextEventForBroadcasterWithType (Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp)
 387 {
 388     return GetNextEventInternal (broadcaster, NULL, 0, event_type_mask, event_sp);
 389 }
 390
 391
 392 bool
 393 Listener::WaitForEventsInternal
 394 (
 395     const TimeValue *timeout,
 396     Broadcaster *broadcaster,   // NULL for any broadcaster
 397     const ConstString *broadcaster_names, // NULL for any event
 398     uint32_t num_broadcaster_names,
 399     uint32_t event_type_mask,
 400     EventSP &event_sp
 401 )
 402 {
 403     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
 404     bool timed_out = false;
 405
 406     if (log)
 407     {
 408         log->Printf ("%p Listener::WaitForEventsInternal (timeout = { %p }) for %s",
 409                     this, timeout, m_name.c_str());
 410     }
 411
 412     while (1)
 413     {
 414         // Note, we don't want to lock the m_events_mutex in the call to GetNextEventInternal, since the DoOnRemoval
 415         // code might require that new events be serviced.  For instance, the Breakpoint Command's
 416         if (GetNextEventInternal (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask, event_sp))
 417                 return true;
 418
 419         {
 420             // Reset condition value to false, so we can wait for new events to be
 421             // added that might meet our current filter
 422             // But first poll for any new event that might satisfy our condition, and if so consume it,
 423             // otherwise wait.
 424
 425             Mutex::Locker event_locker(m_events_mutex);
 426             const bool remove = false;
 427             if (FindNextEventInternal (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask, event_sp, remove))
 428                 continue;
 429             else
 430                 m_cond_wait.SetValue (false, eBroadcastNever);
 431         }
 432
 433         if (m_cond_wait.WaitForValueEqualTo (true, timeout, &timed_out))
 434             continue;
 435
 436         else if (timed_out)
 437         {
 438             log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS);
 439             if (log)
 440                 log->Printf ("%p Listener::WaitForEventsInternal() timed out for %s", this, m_name.c_str());
 441             break;
 442         }
 443         else
 444         {
 445             log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS);
 446             if (log)
 447                 log->Printf ("%p Listener::WaitForEventsInternal() unknown error for %s", this, m_name.c_str());
 448             break;
 449         }
 450     }
 451
 452     return false;
 453 }
 454
 455 bool
 456 Listener::WaitForEventForBroadcasterWithType
 457 (
 458     const TimeValue *timeout,
 459     Broadcaster *broadcaster,
 460     uint32_t event_type_mask,
 461     EventSP &event_sp
 462 )
 463 {
 464     return WaitForEventsInternal (timeout, broadcaster, NULL, 0, event_type_mask, event_sp);
 465 }
 466
 467 bool
 468 Listener::WaitForEventForBroadcaster
 469 (
 470     const TimeValue *timeout,
 471     Broadcaster *broadcaster,
 472     EventSP &event_sp
 473 )
 474 {
 475     return WaitForEventsInternal (timeout, broadcaster, NULL, 0, 0, event_sp);
 476 }
 477
 478 bool
 479 Listener::WaitForEvent (const TimeValue *timeout, EventSP &event_sp)
 480 {
 481     return WaitForEventsInternal (timeout, NULL, NULL, 0, 0, event_sp);
 482 }
 483
 484 //Listener::broadcaster_collection::iterator
 485 //Listener::FindBroadcasterWithMask (Broadcaster *broadcaster, uint32_t event_mask, bool exact)
 486 //{
 487 //    broadcaster_collection::iterator pos;
 488 //    broadcaster_collection::iterator end = m_broadcasters.end();
 489 //    for (pos = m_broadcasters.find (broadcaster);
 490 //        pos != end && pos->first == broadcaster;
 491 //        ++pos)
 492 //    {
 493 //        if (exact)
 494 //        {
 495 //            if ((event_mask & pos->second.event_mask) == event_mask)
 496 //                return pos;
 497 //        }
 498 //        else
 499 //        {
 500 //            if (event_mask & pos->second.event_mask)
 501 //                return pos;
 502 //        }
 503 //    }
 504 //    return end;
 505 //}
 506
 507 size_t
 508 Listener::HandleBroadcastEvent (EventSP &event_sp)
 509 {
 510     size_t num_handled = 0;
 511     Mutex::Locker locker(m_broadcasters_mutex);
 512     Broadcaster *broadcaster = event_sp->GetBroadcaster();
 513     broadcaster_collection::iterator pos;
 514     broadcaster_collection::iterator end = m_broadcasters.end();
 515     for (pos = m_broadcasters.find (broadcaster);
 516         pos != end && pos->first == broadcaster;
 517         ++pos)
 518     {
 519         BroadcasterInfo info = pos->second;
 520         if (event_sp->GetType () & info.event_mask)
 521         {
 522             if (info.callback != NULL)
 523             {
 524                 info.callback (event_sp, info.callback_user_data);
 525                 ++num_handled;
 526             }
 527         }
 528     }
 529     return num_handled;
 530 }
 531
 532 uint32_t
 533 Listener::StartListeningForEventSpec (BroadcasterManager &manager,
 534                              const BroadcastEventSpec &event_spec)
 535 {
 536     // The BroadcasterManager mutex must be locked before m_broadcasters_mutex
 537     // to avoid violating the lock hierarchy (manager before broadcasters).
 538     Mutex::Locker manager_locker(manager.m_manager_mutex);
 539     Mutex::Locker locker(m_broadcasters_mutex);
 540
 541     uint32_t bits_acquired = manager.RegisterListenerForEvents(*this, event_spec);
 542     if (bits_acquired)
 543         m_broadcaster_managers.push_back(&manager);
 544
 545     return bits_acquired;
 546 }
 547
 548 bool
 549 Listener::StopListeningForEventSpec (BroadcasterManager &manager,
 550                              const BroadcastEventSpec &event_spec)
 551 {
 552     Mutex::Locker locker(m_broadcasters_mutex);
 553     return manager.UnregisterListenerForEvents (*this, event_spec);
 554
 555 }
 556
 557