This is an archive of the discontinued LLVM Phabricator instance.

Differential D55361

Move Broadcaster+Listener+Event combo from Core into Utility
ClosedPublic

Authored by labath on Dec 6 2018, 3:04 AM.

Details

Reviewers
zturner
jingham
teemperor
clayborg
Commits
rG181b823b0478: Move Broadcaster+Listener+Event combo from Core into Utility
rLLDB349157: Move Broadcaster+Listener+Event combo from Core into Utility
rL349157: Move Broadcaster+Listener+Event combo from Core into Utility
Summary

These are general purpose "utility" classes, whose functionality is not
debugger-specific in any way. As such, I believe they belong in the
Utility module.

This doesn't break any particular dependency (yet), but it reduces the
number of Core dependencies across the board.

Diff Detail

Repository
rL LLVM

Event Timeline

labath created this revision.Dec 6 2018, 3:04 AM
Herald added a subscriber: mgorny. · View Herald TranscriptDec 6 2018, 3:04 AM
Harbormaster completed remote builds in B25760: Diff 176946.Dec 6 2018, 3:06 AM
brucem added a subscriber: brucem.Dec 6 2018, 3:16 AM

I recognize that it might be dull, but should you re-sort the various include lists so that the now-in-Utility headers are listed with the other Utility headers?

labath updated this revision to Diff 176948.Dec 6 2018, 3:27 AM

That's a good point, thanks for reminding me.

Re-clang-formatting the changed lines.

Harbormaster completed remote builds in B25762: Diff 176948.Dec 6 2018, 3:27 AM
teemperor added a comment.Dec 6 2018, 10:00 AM

LGTM modulo the unrelated clang-format changes. Feel free to commit them separately (even though the m_event_names fix looks a bit strange).

include/lldb/Utility/Broadcaster.h
551 ↗(On Diff #176948)

What was changed here? I assume clang-format fallout, so can we drop this?

source/Utility/Broadcaster.cpp
229 ↗(On Diff #176948)

Also unrelated.

239 ↗(On Diff #176948)

Also unrelated.

source/Utility/Event.cpp
139 ↗(On Diff #176948)

Also unrelated it seems.

teemperor accepted this revision.Dec 6 2018, 10:00 AM
This revision is now accepted and ready to land.Dec 6 2018, 10:00 AM
labath updated this revision to Diff 177212.Dec 7 2018, 7:24 AM
labath marked 3 inline comments as done.

Thanks for the review.

Yes the changes were done by clang-format, which even in the diff-only mode
doesn't know the difference between a moved file and a newly created one. I hope
this version successfully reverts those.

I'll keep this open a bit more to see if anyone else wants to say something. If
not I'll commit some time next week.

Harbormaster completed remote builds in B25830: Diff 177212.Dec 7 2018, 7:25 AM
Closed by commit rL349157: Move Broadcaster+Listener+Event combo from Core into Utility (authored by labath). · Explain WhyDec 14 2018, 8:03 AM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptDec 14 2018, 8:03 AM

Revision Contents

PathSize
lldb/
trunk/
include/
lldb/
Breakpoint/
2 lines
2 lines
Core/
598 lines
2 lines
2 lines
274 lines
161 lines
2 lines
Interpreter/
6 lines
2 lines
Target/
6 lines
2 lines
2 lines
4 lines
Utility/
598 lines
274 lines
161 lines
source/
API/
2 lines
2 lines
2 lines
4 lines
2 lines
Core/
479 lines
3 lines
4 lines
4 lines
301 lines
470 lines
Plugins/
Process/
MacOSX-Kernel/
2 lines
2 lines
Utility/
4 lines
gdb-remote/
4 lines
2 lines
2 lines
2 lines
Target/
2 lines
8 lines
4 lines
Utility/
479 lines
3 lines
301 lines
470 lines
unittests/
Core/
75 lines
3 lines
25 lines
114 lines
Utility/
75 lines
3 lines
25 lines
114 lines

Diff 178234

lldb/trunk/include/lldb/Breakpoint/Breakpoint.h

Show All 15 Lines
#include <vector> #include <vector>
#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/BreakpointLocationCollection.h" #include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/BreakpointLocationList.h" #include "lldb/Breakpoint/BreakpointLocationList.h"
#include "lldb/Breakpoint/BreakpointName.h" #include "lldb/Breakpoint/BreakpointName.h"
#include "lldb/Breakpoint/BreakpointOptions.h" #include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/Stoppoint.h" #include "lldb/Breakpoint/Stoppoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" Class that /// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" Class that
/// manages logical breakpoint setting. /// manages logical breakpoint setting.
▲ Show 20 Lines • Show All 761 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Breakpoint/BreakpointName.h

Show All 14 Lines
#include <unordered_set> #include <unordered_set>
#include <vector> #include <vector>
#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/BreakpointLocationCollection.h" #include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Breakpoint/BreakpointLocationList.h" #include "lldb/Breakpoint/BreakpointLocationList.h"
#include "lldb/Breakpoint/BreakpointOptions.h" #include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Breakpoint/Stoppoint.h" #include "lldb/Breakpoint/Stoppoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Flags.h" #include "lldb/Utility/Flags.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
namespace lldb_private { namespace lldb_private {
class BreakpointName { class BreakpointName {
public: public:
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Broadcaster.h

//===-- Broadcaster.h -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Broadcaster_h_
#define liblldb_Broadcaster_h_
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/SmallVector.h"
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <utility>
#include <vector>
namespace lldb_private {
class Broadcaster;
}
namespace lldb_private {
class EventData;
}
namespace lldb_private {
class Listener;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------
// lldb::BroadcastEventSpec
//
// This class is used to specify a kind of event to register for. The Debugger
// maintains a list of BroadcastEventSpec's and when it is made
//----------------------------------------------------------------------
class BroadcastEventSpec {
public:
BroadcastEventSpec(const ConstString &broadcaster_class, uint32_t event_bits)
: m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {}
BroadcastEventSpec(const BroadcastEventSpec &rhs);
~BroadcastEventSpec() = default;
const ConstString &GetBroadcasterClass() const { return m_broadcaster_class; }
uint32_t GetEventBits() const { return m_event_bits; }
// Tell whether this BroadcastEventSpec is contained in in_spec. That is: (a)
// the two spec's share the same broadcaster class (b) the event bits of this
// spec are wholly contained in those of in_spec.
bool IsContainedIn(BroadcastEventSpec in_spec) const {
if (m_broadcaster_class != in_spec.GetBroadcasterClass())
return false;
uint32_t in_bits = in_spec.GetEventBits();
if (in_bits == m_event_bits)
return true;
else {
if ((m_event_bits & in_bits) != 0 && (m_event_bits & ~in_bits) == 0)
return true;
}
return false;
}
bool operator<(const BroadcastEventSpec &rhs) const;
BroadcastEventSpec &operator=(const BroadcastEventSpec &rhs);
private:
ConstString m_broadcaster_class;
uint32_t m_event_bits;
};
class BroadcasterManager
: public std::enable_shared_from_this<BroadcasterManager> {
public:
friend class Listener;
protected:
BroadcasterManager();
public:
// Listeners hold onto weak pointers to their broadcaster managers. So they
// must be made into shared pointers, which you do with
// MakeBroadcasterManager.
static lldb::BroadcasterManagerSP MakeBroadcasterManager();
~BroadcasterManager() = default;
uint32_t RegisterListenerForEvents(const lldb::ListenerSP &listener_sp,
BroadcastEventSpec event_spec);
bool UnregisterListenerForEvents(const lldb::ListenerSP &listener_sp,
BroadcastEventSpec event_spec);
lldb::ListenerSP GetListenerForEventSpec(BroadcastEventSpec event_spec) const;
void SignUpListenersForBroadcaster(Broadcaster &broadcaster);
void RemoveListener(const lldb::ListenerSP &listener_sp);
void RemoveListener(Listener *listener);
void Clear();
private:
typedef std::pair<BroadcastEventSpec, lldb::ListenerSP> event_listener_key;
typedef std::map<BroadcastEventSpec, lldb::ListenerSP> collection;
typedef std::set<lldb::ListenerSP> listener_collection;
collection m_event_map;
listener_collection m_listeners;
mutable std::recursive_mutex m_manager_mutex;
// A couple of comparator classes for find_if:
class BroadcasterClassMatches {
public:
BroadcasterClassMatches(const ConstString &broadcaster_class)
: m_broadcaster_class(broadcaster_class) {}
~BroadcasterClassMatches() = default;
bool operator()(const event_listener_key input) const {
return (input.first.GetBroadcasterClass() == m_broadcaster_class);
}
private:
ConstString m_broadcaster_class;
};
class BroadcastEventSpecMatches {
public:
BroadcastEventSpecMatches(BroadcastEventSpec broadcaster_spec)
: m_broadcaster_spec(broadcaster_spec) {}
~BroadcastEventSpecMatches() = default;
bool operator()(const event_listener_key input) const {
return (input.first.IsContainedIn(m_broadcaster_spec));
}
private:
BroadcastEventSpec m_broadcaster_spec;
};
class ListenerMatchesAndSharedBits {
public:
explicit ListenerMatchesAndSharedBits(BroadcastEventSpec broadcaster_spec,
const lldb::ListenerSP listener_sp)
: m_broadcaster_spec(broadcaster_spec), m_listener_sp(listener_sp) {}
~ListenerMatchesAndSharedBits() = default;
bool operator()(const event_listener_key input) const {
return (input.first.GetBroadcasterClass() ==
m_broadcaster_spec.GetBroadcasterClass() &&
(input.first.GetEventBits() &
m_broadcaster_spec.GetEventBits()) != 0 &&
input.second == m_listener_sp);
}
private:
BroadcastEventSpec m_broadcaster_spec;
const lldb::ListenerSP m_listener_sp;
};
class ListenerMatches {
public:
explicit ListenerMatches(const lldb::ListenerSP in_listener_sp)
: m_listener_sp(in_listener_sp) {}
~ListenerMatches() = default;
bool operator()(const event_listener_key input) const {
if (input.second == m_listener_sp)
return true;
else
return false;
}
private:
const lldb::ListenerSP m_listener_sp;
};
class ListenerMatchesPointer {
public:
ListenerMatchesPointer(const Listener *in_listener)
: m_listener(in_listener) {}
~ListenerMatchesPointer() = default;
bool operator()(const event_listener_key input) const {
if (input.second.get() == m_listener)
return true;
else
return false;
}
bool operator()(const lldb::ListenerSP input) const {
if (input.get() == m_listener)
return true;
else
return false;
}
private:
const Listener *m_listener;
};
};
//----------------------------------------------------------------------
/// @class Broadcaster Broadcaster.h "lldb/Core/Broadcaster.h" An event
/// broadcasting class.
///
/// The Broadcaster class is designed to be subclassed by objects that wish to
/// vend events in a multi-threaded environment. Broadcaster objects can each
/// vend 32 events. Each event is represented by a bit in a 32 bit value and
/// these bits can be set:
/// @see Broadcaster::SetEventBits(uint32_t)
/// or cleared:
/// @see Broadcaster::ResetEventBits(uint32_t)
/// When an event gets set the Broadcaster object will notify the Listener
/// object that is listening for the event (if there is one).
///
/// Subclasses should provide broadcast bit definitions for any events they
/// vend, typically using an enumeration:
/// \code
/// class Foo : public Broadcaster
/// {
/// public:
/// //----------------------------------------------------------
/// // Broadcaster event bits definitions.
/// //----------------------------------------------------------
/// enum
/// {
/// eBroadcastBitOne = (1 << 0),
/// eBroadcastBitTwo = (1 << 1),
/// eBroadcastBitThree = (1 << 2),
/// ...
/// };
/// \endcode
//----------------------------------------------------------------------
class Broadcaster {
friend class Listener;
friend class Event;
public:
//------------------------------------------------------------------
/// Construct with a broadcaster with a name.
///
/// @param[in] name
/// A NULL terminated C string that contains the name of the
/// broadcaster object.
//------------------------------------------------------------------
Broadcaster(lldb::BroadcasterManagerSP manager_sp, const char *name);
//------------------------------------------------------------------
/// Destructor.
///
/// The destructor is virtual since this class gets subclassed.
//------------------------------------------------------------------
virtual ~Broadcaster();
void CheckInWithManager();
//------------------------------------------------------------------
/// Broadcast an event which has no associated data.
///
/// @param[in] event_type
/// The element from the enum defining this broadcaster's events
/// that is being broadcast.
///
/// @param[in] event_data
/// User event data that will be owned by the lldb::Event that
/// is created internally.
///
/// @param[in] unique
/// If true, then only add an event of this type if there isn't
/// one already in the queue.
///
//------------------------------------------------------------------
void BroadcastEvent(lldb::EventSP &event_sp) {
m_broadcaster_sp->BroadcastEvent(event_sp);
}
void BroadcastEventIfUnique(lldb::EventSP &event_sp) {
m_broadcaster_sp->BroadcastEventIfUnique(event_sp);
}
void BroadcastEvent(uint32_t event_type,
const lldb::EventDataSP &event_data_sp) {
m_broadcaster_sp->BroadcastEvent(event_type, event_data_sp);
}
void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr) {
m_broadcaster_sp->BroadcastEvent(event_type, event_data);
}
void BroadcastEventIfUnique(uint32_t event_type,
EventData *event_data = nullptr) {
m_broadcaster_sp->BroadcastEventIfUnique(event_type, event_data);
}
void Clear() { m_broadcaster_sp->Clear(); }
virtual void AddInitialEventsToListener(const lldb::ListenerSP &listener_sp,
uint32_t requested_events);
//------------------------------------------------------------------
/// Listen for any events specified by \a event_mask.
///
/// Only one listener can listen to each event bit in a given Broadcaster.
/// Once a listener has acquired an event bit, no other broadcaster will
/// have access to it until it is relinquished by the first listener that
/// gets it. The actual event bits that get acquired by \a listener may be
/// different from what is requested in \a event_mask, and to track this the
/// actual event bits that are acquired get returned.
///
/// @param[in] listener
/// The Listener object that wants to monitor the events that
/// get broadcast by this object.
///
/// @param[in] event_mask
/// A bit mask that indicates which events the listener is
/// asking to monitor.
///
/// @return
/// The actual event bits that were acquired by \a listener.
//------------------------------------------------------------------
uint32_t AddListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask) {
return m_broadcaster_sp->AddListener(listener_sp, event_mask);
}
//------------------------------------------------------------------
/// Get the NULL terminated C string name of this Broadcaster object.
///
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
const ConstString &GetBroadcasterName() { return m_broadcaster_name; }
//------------------------------------------------------------------
/// Get the event name(s) for one or more event bits.
///
/// @param[in] event_mask
/// A bit mask that indicates which events to get names for.
///
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
bool GetEventNames(Stream &s, const uint32_t event_mask,
bool prefix_with_broadcaster_name) const {
return m_broadcaster_sp->GetEventNames(s, event_mask,
prefix_with_broadcaster_name);
}
//------------------------------------------------------------------
/// Set the name for an event bit.
///
/// @param[in] event_mask
/// A bit mask that indicates which events the listener is
/// asking to monitor.
///
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
void SetEventName(uint32_t event_mask, const char *name) {
m_broadcaster_sp->SetEventName(event_mask, name);
}
const char *GetEventName(uint32_t event_mask) const {
return m_broadcaster_sp->GetEventName(event_mask);
}
bool EventTypeHasListeners(uint32_t event_type) {
return m_broadcaster_sp->EventTypeHasListeners(event_type);
}
//------------------------------------------------------------------
/// Removes a Listener from this broadcasters list and frees the event bits
/// specified by \a event_mask that were previously acquired by \a listener
/// (assuming \a listener was listening to this object) for other listener
/// objects to use.
///
/// @param[in] listener
/// A Listener object that previously called AddListener.
///
/// @param[in] event_mask
/// The event bits \a listener wishes to relinquish.
///
/// @return
/// \b True if the listener was listening to this broadcaster
/// and was removed, \b false otherwise.
///
/// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t)
//------------------------------------------------------------------
bool RemoveListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX) {
return m_broadcaster_sp->RemoveListener(listener_sp, event_mask);
}
//------------------------------------------------------------------
/// Provides a simple mechanism to temporarily redirect events from
/// broadcaster. When you call this function passing in a listener and
/// event type mask, all events from the broadcaster matching the mask will
/// now go to the hijacking listener. Only one hijack can occur at a time.
/// If we need more than this we will have to implement a Listener stack.
///
/// @param[in] listener
/// A Listener object. You do not need to call StartListeningForEvents
/// for this broadcaster (that would fail anyway since the event bits
/// would most likely be taken by the listener(s) you are usurping.
///
/// @param[in] event_mask
/// The event bits \a listener wishes to hijack.
///
/// @return
/// \b True if the event mask could be hijacked, \b false otherwise.
///
/// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t)
//------------------------------------------------------------------
bool HijackBroadcaster(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX) {
return m_broadcaster_sp->HijackBroadcaster(listener_sp, event_mask);
}
bool IsHijackedForEvent(uint32_t event_mask) {
return m_broadcaster_sp->IsHijackedForEvent(event_mask);
}
//------------------------------------------------------------------
/// Restore the state of the Broadcaster from a previous hijack attempt.
///
//------------------------------------------------------------------
void RestoreBroadcaster() { m_broadcaster_sp->RestoreBroadcaster(); }
// This needs to be filled in if you are going to register the broadcaster
// with the broadcaster manager and do broadcaster class matching.
// FIXME: Probably should make a ManagedBroadcaster subclass with all the bits
// needed to work
// with the BroadcasterManager, so that it is clearer how to add one.
virtual ConstString &GetBroadcasterClass() const;
lldb::BroadcasterManagerSP GetManager();
protected:
// BroadcasterImpl contains the actual Broadcaster implementation. The
// Broadcaster makes a BroadcasterImpl which lives as long as it does. The
// Listeners & the Events hold a weak pointer to the BroadcasterImpl, so that
// they can survive if a Broadcaster they were listening to is destroyed w/o
// their being able to unregister from it (which can happen if the
// Broadcasters & Listeners are being destroyed on separate threads
// simultaneously. The Broadcaster itself can't be shared out as a weak
// pointer, because some things that are broadcasters (e.g. the Target and
// the Process) are shared in their own right.
//
// For the most part, the Broadcaster functions dispatch to the
// BroadcasterImpl, and are documented in the public Broadcaster API above.
class BroadcasterImpl {
friend class Listener;
friend class Broadcaster;
public:
BroadcasterImpl(Broadcaster &broadcaster);
~BroadcasterImpl() = default;
void BroadcastEvent(lldb::EventSP &event_sp);
void BroadcastEventIfUnique(lldb::EventSP &event_sp);
void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr);
void BroadcastEvent(uint32_t event_type,
const lldb::EventDataSP &event_data_sp);
void BroadcastEventIfUnique(uint32_t event_type,
EventData *event_data = nullptr);
void Clear();
uint32_t AddListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask);
const char *GetBroadcasterName() const {
return m_broadcaster.GetBroadcasterName().AsCString();
}
Broadcaster *GetBroadcaster();
bool GetEventNames(Stream &s, const uint32_t event_mask,
bool prefix_with_broadcaster_name) const;
void SetEventName(uint32_t event_mask, const char *name) {
m_event_names[event_mask] = name;
}
const char *GetEventName(uint32_t event_mask) const {
const auto pos = m_event_names.find(event_mask);
if (pos != m_event_names.end())
return pos->second.c_str();
return nullptr;
}
bool EventTypeHasListeners(uint32_t event_type);
bool RemoveListener(lldb_private::Listener *listener,
uint32_t event_mask = UINT32_MAX);
bool RemoveListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX);
bool HijackBroadcaster(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX);
bool IsHijackedForEvent(uint32_t event_mask);
void RestoreBroadcaster();
protected:
void PrivateBroadcastEvent(lldb::EventSP &event_sp, bool unique);
const char *GetHijackingListenerName();
//------------------------------------------------------------------
//
//------------------------------------------------------------------
typedef llvm::SmallVector<std::pair<lldb::ListenerWP, uint32_t>, 4>
collection;
typedef std::map<uint32_t, std::string> event_names_map;
llvm::SmallVector<std::pair<lldb::ListenerSP, uint32_t &>, 4>
GetListeners();
Broadcaster &m_broadcaster; ///< The broadcaster that this implements
event_names_map m_event_names; ///< Optionally define event names for
///readability and logging for each event bit
collection m_listeners; ///< A list of Listener / event_mask pairs that are
///listening to this broadcaster.
std::recursive_mutex
m_listeners_mutex; ///< A mutex that protects \a m_listeners.
std::vector<lldb::ListenerSP> m_hijacking_listeners; // A simple mechanism
// to intercept events
// from a broadcaster
std::vector<uint32_t> m_hijacking_masks; // At some point we may want to
// have a stack or Listener
// collections, but for now this is just for private hijacking.
private:
//------------------------------------------------------------------
// For Broadcaster only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN(BroadcasterImpl);
};
typedef std::shared_ptr<BroadcasterImpl> BroadcasterImplSP;
typedef std::weak_ptr<BroadcasterImpl> BroadcasterImplWP;
BroadcasterImplSP GetBroadcasterImpl() { return m_broadcaster_sp; }
const char *GetHijackingListenerName() {
return m_broadcaster_sp->GetHijackingListenerName();
}
//------------------------------------------------------------------
// Classes that inherit from Broadcaster can see and modify these
//------------------------------------------------------------------
private:
//------------------------------------------------------------------
// For Broadcaster only
//------------------------------------------------------------------
BroadcasterImplSP m_broadcaster_sp;
lldb::BroadcasterManagerSP m_manager_sp;
const ConstString
m_broadcaster_name; ///< The name of this broadcaster object.
DISALLOW_COPY_AND_ASSIGN(Broadcaster);
};
} // namespace lldb_private
#endif // liblldb_Broadcaster_h_

lldb/trunk/include/lldb/Core/Communication.h

//===-- Communication.h -----------------------------------------*- C++ -*-===// //===-- Communication.h -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_Communication_h_ #ifndef liblldb_Communication_h_
#define liblldb_Communication_h_ #define liblldb_Communication_h_
#include "lldb/Core/Broadcaster.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Timeout.h" #include "lldb/Utility/Timeout.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include <atomic> #include <atomic>
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 385 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Debugger.h

Show All 9 Lines
#ifndef liblldb_Debugger_h_ #ifndef liblldb_Debugger_h_
#define liblldb_Debugger_h_ #define liblldb_Debugger_h_
#include <stdint.h> #include <stdint.h>
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Core/IOHandler.h" #include "lldb/Core/IOHandler.h"
#include "lldb/Core/SourceManager.h" #include "lldb/Core/SourceManager.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/Terminal.h" #include "lldb/Host/Terminal.h"
#include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/UserID.h" #include "lldb/Utility/UserID.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/lldb-private-enumerations.h" #include "lldb/lldb-private-enumerations.h"
▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Event.h

//===-- Event.h -------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Event_h_
#define liblldb_Event_h_
#include "lldb/Core/Broadcaster.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Predicate.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/StringRef.h"
#include <chrono>
#include <memory>
#include <string>
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class Event;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------
// lldb::EventData
//----------------------------------------------------------------------
class EventData {
friend class Event;
public:
EventData();
virtual ~EventData();
virtual const ConstString &GetFlavor() const = 0;
virtual void Dump(Stream *s) const;
private:
virtual void DoOnRemoval(Event *event_ptr) {}
DISALLOW_COPY_AND_ASSIGN(EventData);
};
//----------------------------------------------------------------------
// lldb::EventDataBytes
//----------------------------------------------------------------------
class EventDataBytes : public EventData {
public:
//------------------------------------------------------------------
// Constructors
//------------------------------------------------------------------
EventDataBytes();
EventDataBytes(const char *cstr);
EventDataBytes(llvm::StringRef str);
EventDataBytes(const void *src, size_t src_len);
~EventDataBytes() override;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
const ConstString &GetFlavor() const override;
void Dump(Stream *s) const override;
const void *GetBytes() const;
size_t GetByteSize() const;
void SetBytes(const void *src, size_t src_len);
void SwapBytes(std::string &new_bytes);
void SetBytesFromCString(const char *cstr);
//------------------------------------------------------------------
// Static functions
//------------------------------------------------------------------
static const EventDataBytes *GetEventDataFromEvent(const Event *event_ptr);
static const void *GetBytesFromEvent(const Event *event_ptr);
static size_t GetByteSizeFromEvent(const Event *event_ptr);
static const ConstString &GetFlavorString();
private:
std::string m_bytes;
DISALLOW_COPY_AND_ASSIGN(EventDataBytes);
};
class EventDataReceipt : public EventData {
public:
EventDataReceipt() : EventData(), m_predicate(false) {}
~EventDataReceipt() override {}
static const ConstString &GetFlavorString() {
static ConstString g_flavor("Process::ProcessEventData");
return g_flavor;
}
const ConstString &GetFlavor() const override { return GetFlavorString(); }
bool WaitForEventReceived(const Timeout<std::micro> &timeout = llvm::None) {
return m_predicate.WaitForValueEqualTo(true, timeout);
}
private:
Predicate<bool> m_predicate;
void DoOnRemoval(Event *event_ptr) override {
m_predicate.SetValue(true, eBroadcastAlways);
}
};
//----------------------------------------------------------------------
/// This class handles one or more StructuredData::Dictionary entries
/// that are raised for structured data events.
//----------------------------------------------------------------------
class EventDataStructuredData : public EventData {
public:
//------------------------------------------------------------------
// Constructors
//------------------------------------------------------------------
EventDataStructuredData();
EventDataStructuredData(const lldb::ProcessSP &process_sp,
const StructuredData::ObjectSP &object_sp,
const lldb::StructuredDataPluginSP &plugin_sp);
~EventDataStructuredData() override;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
const ConstString &GetFlavor() const override;
void Dump(Stream *s) const override;
const lldb::ProcessSP &GetProcess() const;
const StructuredData::ObjectSP &GetObject() const;
const lldb::StructuredDataPluginSP &GetStructuredDataPlugin() const;
void SetProcess(const lldb::ProcessSP &process_sp);
void SetObject(const StructuredData::ObjectSP &object_sp);
void SetStructuredDataPlugin(const lldb::StructuredDataPluginSP &plugin_sp);
//------------------------------------------------------------------
// Static functions
//------------------------------------------------------------------
static const EventDataStructuredData *
GetEventDataFromEvent(const Event *event_ptr);
static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr);
static StructuredData::ObjectSP GetObjectFromEvent(const Event *event_ptr);
static lldb::StructuredDataPluginSP
GetPluginFromEvent(const Event *event_ptr);
static const ConstString &GetFlavorString();
private:
lldb::ProcessSP m_process_sp;
StructuredData::ObjectSP m_object_sp;
lldb::StructuredDataPluginSP m_plugin_sp;
DISALLOW_COPY_AND_ASSIGN(EventDataStructuredData);
};
//----------------------------------------------------------------------
// lldb::Event
//----------------------------------------------------------------------
class Event {
friend class Listener;
friend class EventData;
friend class Broadcaster::BroadcasterImpl;
public:
Event(Broadcaster *broadcaster, uint32_t event_type,
EventData *data = nullptr);
Event(Broadcaster *broadcaster, uint32_t event_type,
const lldb::EventDataSP &event_data_sp);
Event(uint32_t event_type, EventData *data = nullptr);
Event(uint32_t event_type, const lldb::EventDataSP &event_data_sp);
~Event();
void Dump(Stream *s) const;
EventData *GetData() { return m_data_sp.get(); }
const EventData *GetData() const { return m_data_sp.get(); }
void SetData(EventData *new_data) { m_data_sp.reset(new_data); }
uint32_t GetType() const { return m_type; }
void SetType(uint32_t new_type) { m_type = new_type; }
Broadcaster *GetBroadcaster() const {
Broadcaster::BroadcasterImplSP broadcaster_impl_sp =
m_broadcaster_wp.lock();
if (broadcaster_impl_sp)
return broadcaster_impl_sp->GetBroadcaster();
else
return nullptr;
}
bool BroadcasterIs(Broadcaster *broadcaster) {
Broadcaster::BroadcasterImplSP broadcaster_impl_sp =
m_broadcaster_wp.lock();
if (broadcaster_impl_sp)
return broadcaster_impl_sp->GetBroadcaster() == broadcaster;
else
return false;
}
void Clear() { m_data_sp.reset(); }
private:
// This is only called by Listener when it pops an event off the queue for
// the listener. It calls the Event Data's DoOnRemoval() method, which is
// virtual and can be overridden by the specific data classes.
void DoOnRemoval();
// Called by Broadcaster::BroadcastEvent prior to letting all the listeners
// know about it update the contained broadcaster so that events can be
// popped off one queue and re-broadcast to others.
void SetBroadcaster(Broadcaster *broadcaster) {
m_broadcaster_wp = broadcaster->GetBroadcasterImpl();
}
Broadcaster::BroadcasterImplWP
m_broadcaster_wp; // The broadcaster that sent this event
uint32_t m_type; // The bit describing this event
lldb::EventDataSP m_data_sp; // User specific data for this event
DISALLOW_COPY_AND_ASSIGN(Event);
Event(); // Disallow default constructor
};
} // namespace lldb_private
#endif // liblldb_Event_h_

lldb/trunk/include/lldb/Core/Listener.h

//===-- Listener.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Select_h_
#define liblldb_Select_h_
#include "lldb/Core/Broadcaster.h"
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include <condition_variable>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <ratio>
#include <string>
#include <vector>
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class Event;
}
namespace lldb_private {
class Listener : public std::enable_shared_from_this<Listener> {
public:
typedef bool (*HandleBroadcastCallback)(lldb::EventSP &event_sp, void *baton);
friend class Broadcaster;
friend class BroadcasterManager;
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
//
// Listeners have to be constructed into shared pointers - at least if you
// want them to listen to Broadcasters,
protected:
Listener(const char *name);
public:
static lldb::ListenerSP MakeListener(const char *name);
~Listener();
void AddEvent(lldb::EventSP &event);
void Clear();
const char *GetName() { return m_name.c_str(); }
uint32_t StartListeningForEventSpec(lldb::BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec);
bool StopListeningForEventSpec(lldb::BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec);
uint32_t StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask);
uint32_t StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask,
HandleBroadcastCallback callback,
void *callback_user_data);
bool StopListeningForEvents(Broadcaster *broadcaster, uint32_t event_mask);
Event *PeekAtNextEvent();
Event *PeekAtNextEventForBroadcaster(Broadcaster *broadcaster);
Event *PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
uint32_t event_type_mask);
// Returns true if an event was received, false if we timed out.
bool GetEvent(lldb::EventSP &event_sp, const Timeout<std::micro> &timeout);
bool GetEventForBroadcaster(Broadcaster *broadcaster, lldb::EventSP &event_sp,
const Timeout<std::micro> &timeout);
bool GetEventForBroadcasterWithType(Broadcaster *broadcaster,
uint32_t event_type_mask,
lldb::EventSP &event_sp,
const Timeout<std::micro> &timeout);
size_t HandleBroadcastEvent(lldb::EventSP &event_sp);
private:
//------------------------------------------------------------------
// Classes that inherit from Listener can see and modify these
//------------------------------------------------------------------
struct BroadcasterInfo {
BroadcasterInfo(uint32_t mask, HandleBroadcastCallback cb = nullptr,
void *ud = nullptr)
: event_mask(mask), callback(cb), callback_user_data(ud) {}
uint32_t event_mask;
HandleBroadcastCallback callback;
void *callback_user_data;
};
typedef std::multimap<Broadcaster::BroadcasterImplWP, BroadcasterInfo,
std::owner_less<Broadcaster::BroadcasterImplWP>>
broadcaster_collection;
typedef std::list<lldb::EventSP> event_collection;
typedef std::vector<lldb::BroadcasterManagerWP>
broadcaster_manager_collection;
bool
FindNextEventInternal(std::unique_lock<std::mutex> &lock,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *sources, // nullptr for any event
uint32_t num_sources, uint32_t event_type_mask,
lldb::EventSP &event_sp, bool remove);
bool GetEventInternal(const Timeout<std::micro> &timeout,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *sources, // nullptr for any event
uint32_t num_sources, uint32_t event_type_mask,
lldb::EventSP &event_sp);
std::string m_name;
broadcaster_collection m_broadcasters;
std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters
event_collection m_events;
std::mutex m_events_mutex; // Protects m_broadcasters and m_events
std::condition_variable m_events_condition;
broadcaster_manager_collection m_broadcaster_managers;
void BroadcasterWillDestruct(Broadcaster *);
void BroadcasterManagerWillDestruct(lldb::BroadcasterManagerSP manager_sp);
// broadcaster_collection::iterator
// FindBroadcasterWithMask (Broadcaster *broadcaster,
// uint32_t event_mask,
// bool exact);
//------------------------------------------------------------------
// For Listener only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN(Listener);
};
} // namespace lldb_private
#endif // liblldb_Select_h_

lldb/trunk/include/lldb/Core/StructuredDataImpl.h

//===-- StructuredDataImpl.h ------------------------------------*- C++ -*-===// //===-- StructuredDataImpl.h ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_StructuredDataImpl_h_ #ifndef liblldb_StructuredDataImpl_h_
#define liblldb_StructuredDataImpl_h_ #define liblldb_StructuredDataImpl_h_
#include "lldb/Core/Event.h"
#include "lldb/Target/StructuredDataPlugin.h" #include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-enumerations.h" #include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#pragma mark-- #pragma mark--
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/CommandInterpreter.h

//===-- CommandInterpreter.h ------------------------------------*- C++ -*-===// //===-- CommandInterpreter.h ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_CommandInterpreter_h_ #ifndef liblldb_CommandInterpreter_h_
#define liblldb_CommandInterpreter_h_ #define liblldb_CommandInterpreter_h_
#include <mutex>
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/IOHandler.h" #include "lldb/Core/IOHandler.h"
#include "lldb/Interpreter/CommandAlias.h" #include "lldb/Interpreter/CommandAlias.h"
#include "lldb/Interpreter/CommandHistory.h" #include "lldb/Interpreter/CommandHistory.h"
#include "lldb/Interpreter/CommandObject.h" #include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/ScriptInterpreter.h" #include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Utility/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/CompletionRequest.h" #include "lldb/Utility/CompletionRequest.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
#include "lldb/lldb-forward.h" #include "lldb/lldb-forward.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include <mutex>
namespace lldb_private { namespace lldb_private {
class CommandInterpreterRunOptions { class CommandInterpreterRunOptions {
public: public:
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Construct a CommandInterpreterRunOptions object. This class is used to /// Construct a CommandInterpreterRunOptions object. This class is used to
/// control all the instances where we run multiple commands, e.g. /// control all the instances where we run multiple commands, e.g.
▲ Show 20 Lines • Show All 584 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

//===-- ScriptInterpreter.h -------------------------------------*- C++ -*-===// //===-- ScriptInterpreter.h -------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ScriptInterpreter_h_ #ifndef liblldb_ScriptInterpreter_h_
#define liblldb_ScriptInterpreter_h_ #define liblldb_ScriptInterpreter_h_
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Breakpoint/BreakpointOptions.h" #include "lldb/Breakpoint/BreakpointOptions.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
#include "lldb/Host/PseudoTerminal.h" #include "lldb/Host/PseudoTerminal.h"
namespace lldb_private { namespace lldb_private {
class ScriptInterpreterLocker { class ScriptInterpreterLocker {
▲ Show 20 Lines • Show All 455 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Process.h

Show All 17 Lines
#include <list> #include <list>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <unordered_set> #include <unordered_set>
#include <vector> #include <vector>
#include "lldb/Breakpoint/BreakpointSiteList.h" #include "lldb/Breakpoint/BreakpointSiteList.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Listener.h"
#include "lldb/Core/LoadedModuleInfoList.h" #include "lldb/Core/LoadedModuleInfoList.h"
#include "lldb/Core/PluginInterface.h" #include "lldb/Core/PluginInterface.h"
#include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/ThreadSafeValue.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/ProcessRunLock.h" #include "lldb/Host/ProcessRunLock.h"
#include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/Options.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/InstrumentationRuntime.h" #include "lldb/Target/InstrumentationRuntime.h"
#include "lldb/Target/Memory.h" #include "lldb/Target/Memory.h"
#include "lldb/Target/ProcessInfo.h" #include "lldb/Target/ProcessInfo.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/QueueList.h" #include "lldb/Target/QueueList.h"
#include "lldb/Target/ThreadList.h" #include "lldb/Target/ThreadList.h"
#include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/NameMatches.h" #include "lldb/Utility/NameMatches.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
#include "lldb/Utility/TraceOptions.h" #include "lldb/Utility/TraceOptions.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/VersionTuple.h" #include "llvm/Support/VersionTuple.h"
▲ Show 20 Lines • Show All 3,209 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Target.h

Show All 14 Lines
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "lldb/Breakpoint/BreakpointList.h" #include "lldb/Breakpoint/BreakpointList.h"
#include "lldb/Breakpoint/BreakpointName.h" #include "lldb/Breakpoint/BreakpointName.h"
#include "lldb/Breakpoint/WatchpointList.h" #include "lldb/Breakpoint/WatchpointList.h"
#include "lldb/Core/Architecture.h" #include "lldb/Core/Architecture.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Expression/Expression.h" #include "lldb/Expression/Expression.h"
#include "lldb/Symbol/TypeSystem.h" #include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/PathMappingList.h" #include "lldb/Target/PathMappingList.h"
#include "lldb/Target/ProcessLaunchInfo.h" #include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/SectionLoadHistory.h" #include "lldb/Target/SectionLoadHistory.h"
#include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Timeout.h" #include "lldb/Utility/Timeout.h"
#include "lldb/lldb-public.h" #include "lldb/lldb-public.h"
namespace lldb_private { namespace lldb_private {
OptionEnumValues GetDynamicValueTypes(); OptionEnumValues GetDynamicValueTypes();
▲ Show 20 Lines • Show All 1,315 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/TargetList.h

//===-- TargetList.h --------------------------------------------*- C++ -*-===// //===-- TargetList.h --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_TargetList_h_ #ifndef liblldb_TargetList_h_
#define liblldb_TargetList_h_ #define liblldb_TargetList_h_
#include <mutex> #include <mutex>
#include <vector> #include <vector>
#include "lldb/Core/Broadcaster.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Broadcaster.h"
namespace lldb_private { namespace lldb_private {
class TargetList : public Broadcaster { class TargetList : public Broadcaster {
private: private:
friend class Debugger; friend class Debugger;
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Thread.h

Show All 9 Lines
#ifndef liblldb_Thread_h_ #ifndef liblldb_Thread_h_
#define liblldb_Thread_h_ #define liblldb_Thread_h_
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/RegisterCheckpoint.h" #include "lldb/Target/RegisterCheckpoint.h"
#include "lldb/Target/StackFrameList.h" #include "lldb/Target/StackFrameList.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
#include "lldb/Utility/UserID.h" #include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#define LLDB_THREAD_MAX_STOP_EXC_DATA 8 #define LLDB_THREAD_MAX_STOP_EXC_DATA 8
namespace lldb_private { namespace lldb_private {
▲ Show 20 Lines • Show All 1,341 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/Broadcaster.h

//===-- Broadcaster.h -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_UTILITY_BROADCASTER_H
#define LLDB_UTILITY_BROADCASTER_H
#include "lldb/Utility/ConstString.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/SmallVector.h"
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <utility>
#include <vector>
namespace lldb_private {
class Broadcaster;
}
namespace lldb_private {
class EventData;
}
namespace lldb_private {
class Listener;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------
// lldb::BroadcastEventSpec
//
// This class is used to specify a kind of event to register for. The Debugger
// maintains a list of BroadcastEventSpec's and when it is made
//----------------------------------------------------------------------
class BroadcastEventSpec {
public:
BroadcastEventSpec(const ConstString &broadcaster_class, uint32_t event_bits)
: m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {}
BroadcastEventSpec(const BroadcastEventSpec &rhs);
~BroadcastEventSpec() = default;
const ConstString &GetBroadcasterClass() const { return m_broadcaster_class; }
uint32_t GetEventBits() const { return m_event_bits; }
// Tell whether this BroadcastEventSpec is contained in in_spec. That is: (a)
// the two spec's share the same broadcaster class (b) the event bits of this
// spec are wholly contained in those of in_spec.
bool IsContainedIn(BroadcastEventSpec in_spec) const {
if (m_broadcaster_class != in_spec.GetBroadcasterClass())
return false;
uint32_t in_bits = in_spec.GetEventBits();
if (in_bits == m_event_bits)
return true;
else {
if ((m_event_bits & in_bits) != 0 && (m_event_bits & ~in_bits) == 0)
return true;
}
return false;
}
bool operator<(const BroadcastEventSpec &rhs) const;
BroadcastEventSpec &operator=(const BroadcastEventSpec &rhs);
private:
ConstString m_broadcaster_class;
uint32_t m_event_bits;
};
class BroadcasterManager
: public std::enable_shared_from_this<BroadcasterManager> {
public:
friend class Listener;
protected:
BroadcasterManager();
public:
// Listeners hold onto weak pointers to their broadcaster managers. So they
// must be made into shared pointers, which you do with
// MakeBroadcasterManager.
static lldb::BroadcasterManagerSP MakeBroadcasterManager();
~BroadcasterManager() = default;
uint32_t RegisterListenerForEvents(const lldb::ListenerSP &listener_sp,
BroadcastEventSpec event_spec);
bool UnregisterListenerForEvents(const lldb::ListenerSP &listener_sp,
BroadcastEventSpec event_spec);
lldb::ListenerSP GetListenerForEventSpec(BroadcastEventSpec event_spec) const;
void SignUpListenersForBroadcaster(Broadcaster &broadcaster);
void RemoveListener(const lldb::ListenerSP &listener_sp);
void RemoveListener(Listener *listener);
void Clear();
private:
typedef std::pair<BroadcastEventSpec, lldb::ListenerSP> event_listener_key;
typedef std::map<BroadcastEventSpec, lldb::ListenerSP> collection;
typedef std::set<lldb::ListenerSP> listener_collection;
collection m_event_map;
listener_collection m_listeners;
mutable std::recursive_mutex m_manager_mutex;
// A couple of comparator classes for find_if:
class BroadcasterClassMatches {
public:
BroadcasterClassMatches(const ConstString &broadcaster_class)
: m_broadcaster_class(broadcaster_class) {}
~BroadcasterClassMatches() = default;
bool operator()(const event_listener_key input) const {
return (input.first.GetBroadcasterClass() == m_broadcaster_class);
}
private:
ConstString m_broadcaster_class;
};
class BroadcastEventSpecMatches {
public:
BroadcastEventSpecMatches(BroadcastEventSpec broadcaster_spec)
: m_broadcaster_spec(broadcaster_spec) {}
~BroadcastEventSpecMatches() = default;
bool operator()(const event_listener_key input) const {
return (input.first.IsContainedIn(m_broadcaster_spec));
}
private:
BroadcastEventSpec m_broadcaster_spec;
};
class ListenerMatchesAndSharedBits {
public:
explicit ListenerMatchesAndSharedBits(BroadcastEventSpec broadcaster_spec,
const lldb::ListenerSP listener_sp)
: m_broadcaster_spec(broadcaster_spec), m_listener_sp(listener_sp) {}
~ListenerMatchesAndSharedBits() = default;
bool operator()(const event_listener_key input) const {
return (input.first.GetBroadcasterClass() ==
m_broadcaster_spec.GetBroadcasterClass() &&
(input.first.GetEventBits() &
m_broadcaster_spec.GetEventBits()) != 0 &&
input.second == m_listener_sp);
}
private:
BroadcastEventSpec m_broadcaster_spec;
const lldb::ListenerSP m_listener_sp;
};
class ListenerMatches {
public:
explicit ListenerMatches(const lldb::ListenerSP in_listener_sp)
: m_listener_sp(in_listener_sp) {}
~ListenerMatches() = default;
bool operator()(const event_listener_key input) const {
if (input.second == m_listener_sp)
return true;
else
return false;
}
private:
const lldb::ListenerSP m_listener_sp;
};
class ListenerMatchesPointer {
public:
ListenerMatchesPointer(const Listener *in_listener)
: m_listener(in_listener) {}
~ListenerMatchesPointer() = default;
bool operator()(const event_listener_key input) const {
if (input.second.get() == m_listener)
return true;
else
return false;
}
bool operator()(const lldb::ListenerSP input) const {
if (input.get() == m_listener)
return true;
else
return false;
}
private:
const Listener *m_listener;
};
};
//----------------------------------------------------------------------
/// @class Broadcaster Broadcaster.h "lldb/Utility/Broadcaster.h" An event
/// broadcasting class.
///
/// The Broadcaster class is designed to be subclassed by objects that wish to
/// vend events in a multi-threaded environment. Broadcaster objects can each
/// vend 32 events. Each event is represented by a bit in a 32 bit value and
/// these bits can be set:
/// @see Broadcaster::SetEventBits(uint32_t)
/// or cleared:
/// @see Broadcaster::ResetEventBits(uint32_t)
/// When an event gets set the Broadcaster object will notify the Listener
/// object that is listening for the event (if there is one).
///
/// Subclasses should provide broadcast bit definitions for any events they
/// vend, typically using an enumeration:
/// \code
/// class Foo : public Broadcaster
/// {
/// public:
/// //----------------------------------------------------------
/// // Broadcaster event bits definitions.
/// //----------------------------------------------------------
/// enum
/// {
/// eBroadcastBitOne = (1 << 0),
/// eBroadcastBitTwo = (1 << 1),
/// eBroadcastBitThree = (1 << 2),
/// ...
/// };
/// \endcode
//----------------------------------------------------------------------
class Broadcaster {
friend class Listener;
friend class Event;
public:
//------------------------------------------------------------------
/// Construct with a broadcaster with a name.
///
/// @param[in] name
/// A NULL terminated C string that contains the name of the
/// broadcaster object.
//------------------------------------------------------------------
Broadcaster(lldb::BroadcasterManagerSP manager_sp, const char *name);
//------------------------------------------------------------------
/// Destructor.
///
/// The destructor is virtual since this class gets subclassed.
//------------------------------------------------------------------
virtual ~Broadcaster();
void CheckInWithManager();
//------------------------------------------------------------------
/// Broadcast an event which has no associated data.
///
/// @param[in] event_type
/// The element from the enum defining this broadcaster's events
/// that is being broadcast.
///
/// @param[in] event_data
/// User event data that will be owned by the lldb::Event that
/// is created internally.
///
/// @param[in] unique
/// If true, then only add an event of this type if there isn't
/// one already in the queue.
///
//------------------------------------------------------------------
void BroadcastEvent(lldb::EventSP &event_sp) {
m_broadcaster_sp->BroadcastEvent(event_sp);
}
void BroadcastEventIfUnique(lldb::EventSP &event_sp) {
m_broadcaster_sp->BroadcastEventIfUnique(event_sp);
}
void BroadcastEvent(uint32_t event_type,
const lldb::EventDataSP &event_data_sp) {
m_broadcaster_sp->BroadcastEvent(event_type, event_data_sp);
}
void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr) {
m_broadcaster_sp->BroadcastEvent(event_type, event_data);
}
void BroadcastEventIfUnique(uint32_t event_type,
EventData *event_data = nullptr) {
m_broadcaster_sp->BroadcastEventIfUnique(event_type, event_data);
}
void Clear() { m_broadcaster_sp->Clear(); }
virtual void AddInitialEventsToListener(const lldb::ListenerSP &listener_sp,
uint32_t requested_events);
//------------------------------------------------------------------
/// Listen for any events specified by \a event_mask.
///
/// Only one listener can listen to each event bit in a given Broadcaster.
/// Once a listener has acquired an event bit, no other broadcaster will
/// have access to it until it is relinquished by the first listener that
/// gets it. The actual event bits that get acquired by \a listener may be
/// different from what is requested in \a event_mask, and to track this the
/// actual event bits that are acquired get returned.
///
/// @param[in] listener
/// The Listener object that wants to monitor the events that
/// get broadcast by this object.
///
/// @param[in] event_mask
/// A bit mask that indicates which events the listener is
/// asking to monitor.
///
/// @return
/// The actual event bits that were acquired by \a listener.
//------------------------------------------------------------------
uint32_t AddListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask) {
return m_broadcaster_sp->AddListener(listener_sp, event_mask);
}
//------------------------------------------------------------------
/// Get the NULL terminated C string name of this Broadcaster object.
///
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
const ConstString &GetBroadcasterName() { return m_broadcaster_name; }
//------------------------------------------------------------------
/// Get the event name(s) for one or more event bits.
///
/// @param[in] event_mask
/// A bit mask that indicates which events to get names for.
///
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
bool GetEventNames(Stream &s, const uint32_t event_mask,
bool prefix_with_broadcaster_name) const {
return m_broadcaster_sp->GetEventNames(s, event_mask,
prefix_with_broadcaster_name);
}
//------------------------------------------------------------------
/// Set the name for an event bit.
///
/// @param[in] event_mask
/// A bit mask that indicates which events the listener is
/// asking to monitor.
///
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
void SetEventName(uint32_t event_mask, const char *name) {
m_broadcaster_sp->SetEventName(event_mask, name);
}
const char *GetEventName(uint32_t event_mask) const {
return m_broadcaster_sp->GetEventName(event_mask);
}
bool EventTypeHasListeners(uint32_t event_type) {
return m_broadcaster_sp->EventTypeHasListeners(event_type);
}
//------------------------------------------------------------------
/// Removes a Listener from this broadcasters list and frees the event bits
/// specified by \a event_mask that were previously acquired by \a listener
/// (assuming \a listener was listening to this object) for other listener
/// objects to use.
///
/// @param[in] listener
/// A Listener object that previously called AddListener.
///
/// @param[in] event_mask
/// The event bits \a listener wishes to relinquish.
///
/// @return
/// \b True if the listener was listening to this broadcaster
/// and was removed, \b false otherwise.
///
/// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t)
//------------------------------------------------------------------
bool RemoveListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX) {
return m_broadcaster_sp->RemoveListener(listener_sp, event_mask);
}
//------------------------------------------------------------------
/// Provides a simple mechanism to temporarily redirect events from
/// broadcaster. When you call this function passing in a listener and
/// event type mask, all events from the broadcaster matching the mask will
/// now go to the hijacking listener. Only one hijack can occur at a time.
/// If we need more than this we will have to implement a Listener stack.
///
/// @param[in] listener
/// A Listener object. You do not need to call StartListeningForEvents
/// for this broadcaster (that would fail anyway since the event bits
/// would most likely be taken by the listener(s) you are usurping.
///
/// @param[in] event_mask
/// The event bits \a listener wishes to hijack.
///
/// @return
/// \b True if the event mask could be hijacked, \b false otherwise.
///
/// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t)
//------------------------------------------------------------------
bool HijackBroadcaster(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX) {
return m_broadcaster_sp->HijackBroadcaster(listener_sp, event_mask);
}
bool IsHijackedForEvent(uint32_t event_mask) {
return m_broadcaster_sp->IsHijackedForEvent(event_mask);
}
//------------------------------------------------------------------
/// Restore the state of the Broadcaster from a previous hijack attempt.
///
//------------------------------------------------------------------
void RestoreBroadcaster() { m_broadcaster_sp->RestoreBroadcaster(); }
// This needs to be filled in if you are going to register the broadcaster
// with the broadcaster manager and do broadcaster class matching.
// FIXME: Probably should make a ManagedBroadcaster subclass with all the bits
// needed to work
// with the BroadcasterManager, so that it is clearer how to add one.
virtual ConstString &GetBroadcasterClass() const;
lldb::BroadcasterManagerSP GetManager();
protected:
// BroadcasterImpl contains the actual Broadcaster implementation. The
// Broadcaster makes a BroadcasterImpl which lives as long as it does. The
// Listeners & the Events hold a weak pointer to the BroadcasterImpl, so that
// they can survive if a Broadcaster they were listening to is destroyed w/o
// their being able to unregister from it (which can happen if the
// Broadcasters & Listeners are being destroyed on separate threads
// simultaneously. The Broadcaster itself can't be shared out as a weak
// pointer, because some things that are broadcasters (e.g. the Target and
// the Process) are shared in their own right.
//
// For the most part, the Broadcaster functions dispatch to the
// BroadcasterImpl, and are documented in the public Broadcaster API above.
class BroadcasterImpl {
friend class Listener;
friend class Broadcaster;
public:
BroadcasterImpl(Broadcaster &broadcaster);
~BroadcasterImpl() = default;
void BroadcastEvent(lldb::EventSP &event_sp);
void BroadcastEventIfUnique(lldb::EventSP &event_sp);
void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr);
void BroadcastEvent(uint32_t event_type,
const lldb::EventDataSP &event_data_sp);
void BroadcastEventIfUnique(uint32_t event_type,
EventData *event_data = nullptr);
void Clear();
uint32_t AddListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask);
const char *GetBroadcasterName() const {
return m_broadcaster.GetBroadcasterName().AsCString();
}
Broadcaster *GetBroadcaster();
bool GetEventNames(Stream &s, const uint32_t event_mask,
bool prefix_with_broadcaster_name) const;
void SetEventName(uint32_t event_mask, const char *name) {
m_event_names[event_mask] = name;
}
const char *GetEventName(uint32_t event_mask) const {
const auto pos = m_event_names.find(event_mask);
if (pos != m_event_names.end())
return pos->second.c_str();
return nullptr;
}
bool EventTypeHasListeners(uint32_t event_type);
bool RemoveListener(lldb_private::Listener *listener,
uint32_t event_mask = UINT32_MAX);
bool RemoveListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX);
bool HijackBroadcaster(const lldb::ListenerSP &listener_sp,
uint32_t event_mask = UINT32_MAX);
bool IsHijackedForEvent(uint32_t event_mask);
void RestoreBroadcaster();
protected:
void PrivateBroadcastEvent(lldb::EventSP &event_sp, bool unique);
const char *GetHijackingListenerName();
//------------------------------------------------------------------
//
//------------------------------------------------------------------
typedef llvm::SmallVector<std::pair<lldb::ListenerWP, uint32_t>, 4>
collection;
typedef std::map<uint32_t, std::string> event_names_map;
llvm::SmallVector<std::pair<lldb::ListenerSP, uint32_t &>, 4>
GetListeners();
Broadcaster &m_broadcaster; ///< The broadcaster that this implements
event_names_map m_event_names; ///< Optionally define event names for
///readability and logging for each event bit
collection m_listeners; ///< A list of Listener / event_mask pairs that are
///listening to this broadcaster.
std::recursive_mutex
m_listeners_mutex; ///< A mutex that protects \a m_listeners.
std::vector<lldb::ListenerSP> m_hijacking_listeners; // A simple mechanism
// to intercept events
// from a broadcaster
std::vector<uint32_t> m_hijacking_masks; // At some point we may want to
// have a stack or Listener
// collections, but for now this is just for private hijacking.
private:
//------------------------------------------------------------------
// For Broadcaster only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN(BroadcasterImpl);
};
typedef std::shared_ptr<BroadcasterImpl> BroadcasterImplSP;
typedef std::weak_ptr<BroadcasterImpl> BroadcasterImplWP;
BroadcasterImplSP GetBroadcasterImpl() { return m_broadcaster_sp; }
const char *GetHijackingListenerName() {
return m_broadcaster_sp->GetHijackingListenerName();
}
//------------------------------------------------------------------
// Classes that inherit from Broadcaster can see and modify these
//------------------------------------------------------------------
private:
//------------------------------------------------------------------
// For Broadcaster only
//------------------------------------------------------------------
BroadcasterImplSP m_broadcaster_sp;
lldb::BroadcasterManagerSP m_manager_sp;
const ConstString
m_broadcaster_name; ///< The name of this broadcaster object.
DISALLOW_COPY_AND_ASSIGN(Broadcaster);
};
} // namespace lldb_private
#endif // LLDB_UTILITY_BROADCASTER_H

lldb/trunk/include/lldb/Utility/Event.h

//===-- Event.h -------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_UTILITY_EVENT_H
#define LLDB_UTILITY_EVENT_H
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Predicate.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/StringRef.h"
#include <chrono>
#include <memory>
#include <string>
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class Event;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------
// lldb::EventData
//----------------------------------------------------------------------
class EventData {
friend class Event;
public:
EventData();
virtual ~EventData();
virtual const ConstString &GetFlavor() const = 0;
virtual void Dump(Stream *s) const;
private:
virtual void DoOnRemoval(Event *event_ptr) {}
DISALLOW_COPY_AND_ASSIGN(EventData);
};
//----------------------------------------------------------------------
// lldb::EventDataBytes
//----------------------------------------------------------------------
class EventDataBytes : public EventData {
public:
//------------------------------------------------------------------
// Constructors
//------------------------------------------------------------------
EventDataBytes();
EventDataBytes(const char *cstr);
EventDataBytes(llvm::StringRef str);
EventDataBytes(const void *src, size_t src_len);
~EventDataBytes() override;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
const ConstString &GetFlavor() const override;
void Dump(Stream *s) const override;
const void *GetBytes() const;
size_t GetByteSize() const;
void SetBytes(const void *src, size_t src_len);
void SwapBytes(std::string &new_bytes);
void SetBytesFromCString(const char *cstr);
//------------------------------------------------------------------
// Static functions
//------------------------------------------------------------------
static const EventDataBytes *GetEventDataFromEvent(const Event *event_ptr);
static const void *GetBytesFromEvent(const Event *event_ptr);
static size_t GetByteSizeFromEvent(const Event *event_ptr);
static const ConstString &GetFlavorString();
private:
std::string m_bytes;
DISALLOW_COPY_AND_ASSIGN(EventDataBytes);
};
class EventDataReceipt : public EventData {
public:
EventDataReceipt() : EventData(), m_predicate(false) {}
~EventDataReceipt() override {}
static const ConstString &GetFlavorString() {
static ConstString g_flavor("Process::ProcessEventData");
return g_flavor;
}
const ConstString &GetFlavor() const override { return GetFlavorString(); }
bool WaitForEventReceived(const Timeout<std::micro> &timeout = llvm::None) {
return m_predicate.WaitForValueEqualTo(true, timeout);
}
private:
Predicate<bool> m_predicate;
void DoOnRemoval(Event *event_ptr) override {
m_predicate.SetValue(true, eBroadcastAlways);
}
};
//----------------------------------------------------------------------
/// This class handles one or more StructuredData::Dictionary entries
/// that are raised for structured data events.
//----------------------------------------------------------------------
class EventDataStructuredData : public EventData {
public:
//------------------------------------------------------------------
// Constructors
//------------------------------------------------------------------
EventDataStructuredData();
EventDataStructuredData(const lldb::ProcessSP &process_sp,
const StructuredData::ObjectSP &object_sp,
const lldb::StructuredDataPluginSP &plugin_sp);
~EventDataStructuredData() override;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
const ConstString &GetFlavor() const override;
void Dump(Stream *s) const override;
const lldb::ProcessSP &GetProcess() const;
const StructuredData::ObjectSP &GetObject() const;
const lldb::StructuredDataPluginSP &GetStructuredDataPlugin() const;
void SetProcess(const lldb::ProcessSP &process_sp);
void SetObject(const StructuredData::ObjectSP &object_sp);
void SetStructuredDataPlugin(const lldb::StructuredDataPluginSP &plugin_sp);
//------------------------------------------------------------------
// Static functions
//------------------------------------------------------------------
static const EventDataStructuredData *
GetEventDataFromEvent(const Event *event_ptr);
static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr);
static StructuredData::ObjectSP GetObjectFromEvent(const Event *event_ptr);
static lldb::StructuredDataPluginSP
GetPluginFromEvent(const Event *event_ptr);
static const ConstString &GetFlavorString();
private:
lldb::ProcessSP m_process_sp;
StructuredData::ObjectSP m_object_sp;
lldb::StructuredDataPluginSP m_plugin_sp;
DISALLOW_COPY_AND_ASSIGN(EventDataStructuredData);
};
//----------------------------------------------------------------------
// lldb::Event
//----------------------------------------------------------------------
class Event {
friend class Listener;
friend class EventData;
friend class Broadcaster::BroadcasterImpl;
public:
Event(Broadcaster *broadcaster, uint32_t event_type,
EventData *data = nullptr);
Event(Broadcaster *broadcaster, uint32_t event_type,
const lldb::EventDataSP &event_data_sp);
Event(uint32_t event_type, EventData *data = nullptr);
Event(uint32_t event_type, const lldb::EventDataSP &event_data_sp);
~Event();
void Dump(Stream *s) const;
EventData *GetData() { return m_data_sp.get(); }
const EventData *GetData() const { return m_data_sp.get(); }
void SetData(EventData *new_data) { m_data_sp.reset(new_data); }
uint32_t GetType() const { return m_type; }
void SetType(uint32_t new_type) { m_type = new_type; }
Broadcaster *GetBroadcaster() const {
Broadcaster::BroadcasterImplSP broadcaster_impl_sp =
m_broadcaster_wp.lock();
if (broadcaster_impl_sp)
return broadcaster_impl_sp->GetBroadcaster();
else
return nullptr;
}
bool BroadcasterIs(Broadcaster *broadcaster) {
Broadcaster::BroadcasterImplSP broadcaster_impl_sp =
m_broadcaster_wp.lock();
if (broadcaster_impl_sp)
return broadcaster_impl_sp->GetBroadcaster() == broadcaster;
else
return false;
}
void Clear() { m_data_sp.reset(); }
private:
// This is only called by Listener when it pops an event off the queue for
// the listener. It calls the Event Data's DoOnRemoval() method, which is
// virtual and can be overridden by the specific data classes.
void DoOnRemoval();
// Called by Broadcaster::BroadcastEvent prior to letting all the listeners
// know about it update the contained broadcaster so that events can be
// popped off one queue and re-broadcast to others.
void SetBroadcaster(Broadcaster *broadcaster) {
m_broadcaster_wp = broadcaster->GetBroadcasterImpl();
}
Broadcaster::BroadcasterImplWP
m_broadcaster_wp; // The broadcaster that sent this event
uint32_t m_type; // The bit describing this event
lldb::EventDataSP m_data_sp; // User specific data for this event
DISALLOW_COPY_AND_ASSIGN(Event);
Event(); // Disallow default constructor
};
} // namespace lldb_private
#endif // LLDB_UTILITY_EVENT_H

lldb/trunk/include/lldb/Utility/Listener.h

//===-- Listener.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_UTILITY_LISTENER_H
#define LLDB_UTILITY_LISTENER_H
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
#include <condition_variable>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <ratio>
#include <string>
#include <vector>
#include <stddef.h>
#include <stdint.h>
namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class Event;
}
namespace lldb_private {
class Listener : public std::enable_shared_from_this<Listener> {
public:
typedef bool (*HandleBroadcastCallback)(lldb::EventSP &event_sp, void *baton);
friend class Broadcaster;
friend class BroadcasterManager;
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
//
// Listeners have to be constructed into shared pointers - at least if you
// want them to listen to Broadcasters,
protected:
Listener(const char *name);
public:
static lldb::ListenerSP MakeListener(const char *name);
~Listener();
void AddEvent(lldb::EventSP &event);
void Clear();
const char *GetName() { return m_name.c_str(); }
uint32_t StartListeningForEventSpec(lldb::BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec);
bool StopListeningForEventSpec(lldb::BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec);
uint32_t StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask);
uint32_t StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask,
HandleBroadcastCallback callback,
void *callback_user_data);
bool StopListeningForEvents(Broadcaster *broadcaster, uint32_t event_mask);
Event *PeekAtNextEvent();
Event *PeekAtNextEventForBroadcaster(Broadcaster *broadcaster);
Event *PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
uint32_t event_type_mask);
// Returns true if an event was received, false if we timed out.
bool GetEvent(lldb::EventSP &event_sp, const Timeout<std::micro> &timeout);
bool GetEventForBroadcaster(Broadcaster *broadcaster, lldb::EventSP &event_sp,
const Timeout<std::micro> &timeout);
bool GetEventForBroadcasterWithType(Broadcaster *broadcaster,
uint32_t event_type_mask,
lldb::EventSP &event_sp,
const Timeout<std::micro> &timeout);
size_t HandleBroadcastEvent(lldb::EventSP &event_sp);
private:
//------------------------------------------------------------------
// Classes that inherit from Listener can see and modify these
//------------------------------------------------------------------
struct BroadcasterInfo {
BroadcasterInfo(uint32_t mask, HandleBroadcastCallback cb = nullptr,
void *ud = nullptr)
: event_mask(mask), callback(cb), callback_user_data(ud) {}
uint32_t event_mask;
HandleBroadcastCallback callback;
void *callback_user_data;
};
typedef std::multimap<Broadcaster::BroadcasterImplWP, BroadcasterInfo,
std::owner_less<Broadcaster::BroadcasterImplWP>>
broadcaster_collection;
typedef std::list<lldb::EventSP> event_collection;
typedef std::vector<lldb::BroadcasterManagerWP>
broadcaster_manager_collection;
bool
FindNextEventInternal(std::unique_lock<std::mutex> &lock,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *sources, // nullptr for any event
uint32_t num_sources, uint32_t event_type_mask,
lldb::EventSP &event_sp, bool remove);
bool GetEventInternal(const Timeout<std::micro> &timeout,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *sources, // nullptr for any event
uint32_t num_sources, uint32_t event_type_mask,
lldb::EventSP &event_sp);
std::string m_name;
broadcaster_collection m_broadcasters;
std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters
event_collection m_events;
std::mutex m_events_mutex; // Protects m_broadcasters and m_events
std::condition_variable m_events_condition;
broadcaster_manager_collection m_broadcaster_managers;
void BroadcasterWillDestruct(Broadcaster *);
void BroadcasterManagerWillDestruct(lldb::BroadcasterManagerSP manager_sp);
// broadcaster_collection::iterator
// FindBroadcasterWithMask (Broadcaster *broadcaster,
// uint32_t event_mask,
// bool exact);
//------------------------------------------------------------------
// For Listener only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN(Listener);
};
} // namespace lldb_private
#endif // LLDB_UTILITY_LISTENER_H

lldb/trunk/source/API/SBBroadcaster.cpp

//===-- SBBroadcaster.cpp ---------------------------------------*- C++ -*-===// //===-- SBBroadcaster.cpp ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Broadcaster.h" #include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBListener.h" #include "lldb/API/SBListener.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBCommandInterpreter.cpp

//===-- SBCommandInterpreter.cpp --------------------------------*- C++ -*-===// //===-- SBCommandInterpreter.cpp --------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
#include "lldb/Core/Listener.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObjectMultiword.h" #include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Listener.h"
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBCommandInterpreter.h" #include "lldb/API/SBCommandInterpreter.h"
#include "lldb/API/SBCommandReturnObject.h" #include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBExecutionContext.h" #include "lldb/API/SBExecutionContext.h"
#include "lldb/API/SBListener.h" #include "lldb/API/SBListener.h"
#include "lldb/API/SBProcess.h" #include "lldb/API/SBProcess.h"
▲ Show 20 Lines • Show All 640 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBEvent.cpp

//===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===// //===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {} SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {}
SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len) SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBListener.cpp

//===-- SBListener.cpp ------------------------------------------*- C++ -*-===// //===-- SBListener.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBListener.h" #include "lldb/API/SBListener.h"
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h" #include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h" #include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Listener.h" #include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {} SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(NULL) {}
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBStructuredData.cpp

//===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===// //===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/API/SBStructuredData.h" #include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBStream.h" #include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h" #include "lldb/API/SBStringList.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/StructuredDataImpl.h" #include "lldb/Core/StructuredDataImpl.h"
#include "lldb/Target/StructuredDataPlugin.h" #include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
#pragma mark-- #pragma mark--
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Broadcaster.cpp

//===-- Broadcaster.cpp -----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Listener.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include <algorithm>
#include <memory>
#include <type_traits>
#include <assert.h>
#include <stddef.h>
using namespace lldb;
using namespace lldb_private;
Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name)
: m_broadcaster_sp(std::make_shared<BroadcasterImpl>(*this)),
m_manager_sp(manager_sp), m_broadcaster_name(name) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
if (log)
log->Printf("%p Broadcaster::Broadcaster(\"%s\")",
static_cast<void *>(this), GetBroadcasterName().AsCString());
}
Broadcaster::BroadcasterImpl::BroadcasterImpl(Broadcaster &broadcaster)
: m_broadcaster(broadcaster), m_listeners(), m_listeners_mutex(),
m_hijacking_listeners(), m_hijacking_masks() {}
Broadcaster::~Broadcaster() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
if (log)
log->Printf("%p Broadcaster::~Broadcaster(\"%s\")",
static_cast<void *>(this), m_broadcaster_name.AsCString());
Clear();
}
void Broadcaster::CheckInWithManager() {
if (m_manager_sp) {
m_manager_sp->SignUpListenersForBroadcaster(*this);
}
}
llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4>
Broadcaster::BroadcasterImpl::GetListeners() {
llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4> listeners;
listeners.reserve(m_listeners.size());
for (auto it = m_listeners.begin(); it != m_listeners.end();) {
lldb::ListenerSP curr_listener_sp(it->first.lock());
if (curr_listener_sp && it->second) {
listeners.emplace_back(std::move(curr_listener_sp), it->second);
++it;
} else
it = m_listeners.erase(it);
}
return listeners;
}
void Broadcaster::BroadcasterImpl::Clear() {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
// Make sure the listener forgets about this broadcaster. We do this in the
// broadcaster in case the broadcaster object initiates the removal.
for (auto &pair : GetListeners())
pair.first->BroadcasterWillDestruct(&m_broadcaster);
m_listeners.clear();
}
Broadcaster *Broadcaster::BroadcasterImpl::GetBroadcaster() {
return &m_broadcaster;
}
bool Broadcaster::BroadcasterImpl::GetEventNames(
Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const {
uint32_t num_names_added = 0;
if (event_mask && !m_event_names.empty()) {
event_names_map::const_iterator end = m_event_names.end();
for (uint32_t bit = 1u, mask = event_mask; mask != 0 && bit != 0;
bit <<= 1, mask >>= 1) {
if (mask & 1) {
event_names_map::const_iterator pos = m_event_names.find(bit);
if (pos != end) {
if (num_names_added > 0)
s.PutCString(", ");
if (prefix_with_broadcaster_name) {
s.PutCString(GetBroadcasterName());
s.PutChar('.');
}
s.PutCString(pos->second);
++num_names_added;
}
}
}
}
return num_names_added > 0;
}
void Broadcaster::AddInitialEventsToListener(
const lldb::ListenerSP &listener_sp, uint32_t requested_events) {}
uint32_t
Broadcaster::BroadcasterImpl::AddListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask) {
if (!listener_sp)
return 0;
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
// See if we already have this listener, and if so, update its mask
bool handled = false;
for (auto &pair : GetListeners()) {
if (pair.first == listener_sp) {
handled = true;
pair.second |= event_mask;
m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
break;
}
}
if (!handled) {
// Grant a new listener the available event bits
m_listeners.push_back(
std::make_pair(lldb::ListenerWP(listener_sp), event_mask));
// Individual broadcasters decide whether they have outstanding data when a
// listener attaches, and insert it into the listener with this method.
m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
}
// Return the event bits that were granted to the listener
return event_mask;
}
bool Broadcaster::BroadcasterImpl::EventTypeHasListeners(uint32_t event_type) {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back())
return true;
for (auto &pair : GetListeners()) {
if (pair.second & event_type)
return true;
}
return false;
}
bool Broadcaster::BroadcasterImpl::RemoveListener(
lldb_private::Listener *listener, uint32_t event_mask) {
if (!listener)
return false;
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
for (auto &pair : GetListeners()) {
if (pair.first.get() == listener) {
pair.second &= ~event_mask;
return true;
}
}
return false;
}
bool Broadcaster::BroadcasterImpl::RemoveListener(
const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
return RemoveListener(listener_sp.get(), event_mask);
}
void Broadcaster::BroadcasterImpl::BroadcastEvent(EventSP &event_sp) {
return PrivateBroadcastEvent(event_sp, false);
}
void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(EventSP &event_sp) {
return PrivateBroadcastEvent(event_sp, true);
}
void Broadcaster::BroadcasterImpl::PrivateBroadcastEvent(EventSP &event_sp,
bool unique) {
// Can't add a nullptr event...
if (!event_sp)
return;
// Update the broadcaster on this event
event_sp->SetBroadcaster(&m_broadcaster);
const uint32_t event_type = event_sp->GetType();
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
ListenerSP hijacking_listener_sp;
if (!m_hijacking_listeners.empty()) {
assert(!m_hijacking_masks.empty());
hijacking_listener_sp = m_hijacking_listeners.back();
if ((event_type & m_hijacking_masks.back()) == 0)
hijacking_listener_sp.reset();
}
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log) {
StreamString event_description;
event_sp->Dump(&event_description);
log->Printf("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, "
"unique =%i) hijack = %p",
static_cast<void *>(this), GetBroadcasterName(),
event_description.GetData(), unique,
static_cast<void *>(hijacking_listener_sp.get()));
}
if (hijacking_listener_sp) {
if (unique &&
hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType(
&m_broadcaster, event_type))
return;
hijacking_listener_sp->AddEvent(event_sp);
} else {
for (auto &pair : GetListeners()) {
if (!(pair.second & event_type))
continue;
if (unique &&
pair.first->PeekAtNextEventForBroadcasterWithType(&m_broadcaster,
event_type))
continue;
pair.first->AddEvent(event_sp);
}
}
}
void Broadcaster::BroadcasterImpl::BroadcastEvent(uint32_t event_type,
EventData *event_data) {
auto event_sp = std::make_shared<Event>(event_type, event_data);
PrivateBroadcastEvent(event_sp, false);
}
void Broadcaster::BroadcasterImpl::BroadcastEvent(
uint32_t event_type, const lldb::EventDataSP &event_data_sp) {
auto event_sp = std::make_shared<Event>(event_type, event_data_sp);
PrivateBroadcastEvent(event_sp, false);
}
void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(
uint32_t event_type, EventData *event_data) {
auto event_sp = std::make_shared<Event>(event_type, event_data);
PrivateBroadcastEvent(event_sp, true);
}
bool Broadcaster::BroadcasterImpl::HijackBroadcaster(
const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log)
log->Printf(
"%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
static_cast<void *>(this), GetBroadcasterName(),
listener_sp->m_name.c_str(), static_cast<void *>(listener_sp.get()));
m_hijacking_listeners.push_back(listener_sp);
m_hijacking_masks.push_back(event_mask);
return true;
}
bool Broadcaster::BroadcasterImpl::IsHijackedForEvent(uint32_t event_mask) {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
if (!m_hijacking_listeners.empty())
return (event_mask & m_hijacking_masks.back()) != 0;
return false;
}
const char *Broadcaster::BroadcasterImpl::GetHijackingListenerName() {
if (m_hijacking_listeners.size()) {
return m_hijacking_listeners.back()->GetName();
} else {
return nullptr;
}
}
void Broadcaster::BroadcasterImpl::RestoreBroadcaster() {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
if (!m_hijacking_listeners.empty()) {
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log) {
ListenerSP listener_sp = m_hijacking_listeners.back();
log->Printf("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop "
"listener(\"%s\")=%p)",
static_cast<void *>(this), GetBroadcasterName(),
listener_sp->m_name.c_str(),
static_cast<void *>(listener_sp.get()));
}
m_hijacking_listeners.pop_back();
}
if (!m_hijacking_masks.empty())
m_hijacking_masks.pop_back();
}
ConstString &Broadcaster::GetBroadcasterClass() const {
static ConstString class_name("lldb.anonymous");
return class_name;
}
BroadcastEventSpec::BroadcastEventSpec(const BroadcastEventSpec &rhs) = default;
bool BroadcastEventSpec::operator<(const BroadcastEventSpec &rhs) const {
if (GetBroadcasterClass() == rhs.GetBroadcasterClass()) {
return GetEventBits() < rhs.GetEventBits();
} else {
return GetBroadcasterClass() < rhs.GetBroadcasterClass();
}
}
BroadcastEventSpec &BroadcastEventSpec::
operator=(const BroadcastEventSpec &rhs) = default;
BroadcasterManager::BroadcasterManager() : m_manager_mutex() {}
lldb::BroadcasterManagerSP BroadcasterManager::MakeBroadcasterManager() {
return lldb::BroadcasterManagerSP(new BroadcasterManager());
}
uint32_t BroadcasterManager::RegisterListenerForEvents(
const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
uint32_t available_bits = event_spec.GetEventBits();
while (iter != end_iter &&
(iter = find_if(iter, end_iter,
BroadcasterClassMatches(
event_spec.GetBroadcasterClass()))) != end_iter) {
available_bits &= ~((*iter).first.GetEventBits());
iter++;
}
if (available_bits != 0) {
m_event_map.insert(event_listener_key(
BroadcastEventSpec(event_spec.GetBroadcasterClass(), available_bits),
listener_sp));
m_listeners.insert(listener_sp);
}
return available_bits;
}
bool BroadcasterManager::UnregisterListenerForEvents(
const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
bool removed_some = false;
if (m_listeners.erase(listener_sp) == 0)
return false;
ListenerMatchesAndSharedBits predicate(event_spec, listener_sp);
std::vector<BroadcastEventSpec> to_be_readded;
uint32_t event_bits_to_remove = event_spec.GetEventBits();
// Go through the map and delete the exact matches, and build a list of
// matches that weren't exact to re-add:
while (true) {
collection::iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter) {
break;
} else {
uint32_t iter_event_bits = (*iter).first.GetEventBits();
removed_some = true;
if (event_bits_to_remove != iter_event_bits) {
uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
to_be_readded.push_back(BroadcastEventSpec(
event_spec.GetBroadcasterClass(), new_event_bits));
}
m_event_map.erase(iter);
}
}
// Okay now add back the bits that weren't completely removed:
for (size_t i = 0; i < to_be_readded.size(); i++) {
m_event_map.insert(event_listener_key(to_be_readded[i], listener_sp));
}
return removed_some;
}
ListenerSP BroadcasterManager::GetListenerForEventSpec(
BroadcastEventSpec event_spec) const {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
collection::const_iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter,
BroadcastEventSpecMatches(event_spec));
if (iter != end_iter)
return (*iter).second;
else
return nullptr;
}
void BroadcasterManager::RemoveListener(Listener *listener) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
ListenerMatchesPointer predicate(listener);
listener_collection::iterator iter = m_listeners.begin(),
end_iter = m_listeners.end();
std::find_if(iter, end_iter, predicate);
if (iter != end_iter)
m_listeners.erase(iter);
while (true) {
collection::iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter)
break;
else
m_event_map.erase(iter);
}
}
void BroadcasterManager::RemoveListener(const lldb::ListenerSP &listener_sp) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
ListenerMatches predicate(listener_sp);
if (m_listeners.erase(listener_sp) == 0)
return;
while (true) {
collection::iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter)
break;
else
m_event_map.erase(iter);
}
}
void BroadcasterManager::SignUpListenersForBroadcaster(
Broadcaster &broadcaster) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
while (iter != end_iter &&
(iter = find_if(iter, end_iter,
BroadcasterClassMatches(
broadcaster.GetBroadcasterClass()))) != end_iter) {
(*iter).second->StartListeningForEvents(&broadcaster,
(*iter).first.GetEventBits());
iter++;
}
}
void BroadcasterManager::Clear() {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
listener_collection::iterator end_iter = m_listeners.end();
for (listener_collection::iterator iter = m_listeners.begin();
iter != end_iter; iter++)
(*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());
m_listeners.clear();
m_event_map.clear();
}

lldb/trunk/source/Core/CMakeLists.txt

set(LLDB_CURSES_LIBS) set(LLDB_CURSES_LIBS)
if (NOT LLDB_DISABLE_CURSES) if (NOT LLDB_DISABLE_CURSES)
list(APPEND LLDB_CURSES_LIBS ${CURSES_LIBRARIES}) list(APPEND LLDB_CURSES_LIBS ${CURSES_LIBRARIES})
if(LLVM_ENABLE_TERMINFO AND HAVE_TERMINFO) if(LLVM_ENABLE_TERMINFO AND HAVE_TERMINFO)
list(APPEND LLDB_CURSES_LIBS ${TERMINFO_LIBS}) list(APPEND LLDB_CURSES_LIBS ${TERMINFO_LIBS})
endif() endif()
endif() endif()
add_lldb_library(lldbCore add_lldb_library(lldbCore
Address.cpp Address.cpp
AddressRange.cpp AddressRange.cpp
AddressResolver.cpp AddressResolver.cpp
AddressResolverFileLine.cpp AddressResolverFileLine.cpp
AddressResolverName.cpp AddressResolverName.cpp
Broadcaster.cpp
Communication.cpp Communication.cpp
Debugger.cpp Debugger.cpp
Disassembler.cpp Disassembler.cpp
DumpDataExtractor.cpp DumpDataExtractor.cpp
DumpRegisterValue.cpp DumpRegisterValue.cpp
DynamicLoader.cpp DynamicLoader.cpp
EmulateInstruction.cpp EmulateInstruction.cpp
Event.cpp
FileLineResolver.cpp FileLineResolver.cpp
FileSpecList.cpp FileSpecList.cpp
FormatEntity.cpp FormatEntity.cpp
Highlighter.cpp Highlighter.cpp
IOHandler.cpp IOHandler.cpp
Listener.cpp
Mangled.cpp Mangled.cpp
Module.cpp Module.cpp
ModuleChild.cpp ModuleChild.cpp
ModuleList.cpp ModuleList.cpp
Opcode.cpp Opcode.cpp
PluginManager.cpp PluginManager.cpp
RichManglingContext.cpp RichManglingContext.cpp
SearchFilter.cpp SearchFilter.cpp
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Communication.cpp

//===-- Communication.cpp ---------------------------------------*- C++ -*-===// //===-- Communication.cpp ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Listener.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Utility/Connection.h" #include "lldb/Utility/Connection.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h" #include "lldb/Utility/Logging.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "llvm/ADT/None.h" #include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/Support/Compiler.h" #include "llvm/Support/Compiler.h"
▲ Show 20 Lines • Show All 397 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Debugger.cpp

//===-- Debugger.cpp --------------------------------------------*- C++ -*-===// //===-- Debugger.cpp --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/FormatEntity.h" #include "lldb/Core/FormatEntity.h"
#include "lldb/Core/Listener.h"
#include "lldb/Core/Mangled.h" #include "lldb/Core/Mangled.h"
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamAsynchronousIO.h" #include "lldb/Core/StreamAsynchronousIO.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Expression/REPL.h" #include "lldb/Expression/REPL.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
Show All 14 Lines
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/StructuredDataPlugin.h" #include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadList.h" #include "lldb/Target/ThreadList.h"
#include "lldb/Utility/AnsiTerminal.h" #include "lldb/Utility/AnsiTerminal.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/Reproducer.h" #include "lldb/Utility/Reproducer.h"
#include "lldb/Utility/State.h" #include "lldb/Utility/State.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamCallback.h" #include "lldb/Utility/StreamCallback.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#if defined(_WIN32) #if defined(_WIN32)
▲ Show 20 Lines • Show All 1,683 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Event.cpp

//===-- Event.cpp -----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/Event.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-enumerations.h"
#include <algorithm>
#include <ctype.h>
using namespace lldb;
using namespace lldb_private;
#pragma mark -
#pragma mark Event
//------------------------------------------------------------------
// Event functions
//------------------------------------------------------------------
Event::Event(Broadcaster *broadcaster, uint32_t event_type, EventData *data)
: m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
m_data_sp(data) {}
Event::Event(Broadcaster *broadcaster, uint32_t event_type,
const EventDataSP &event_data_sp)
: m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
m_data_sp(event_data_sp) {}
Event::Event(uint32_t event_type, EventData *data)
: m_broadcaster_wp(), m_type(event_type), m_data_sp(data) {}
Event::Event(uint32_t event_type, const EventDataSP &event_data_sp)
: m_broadcaster_wp(), m_type(event_type), m_data_sp(event_data_sp) {}
Event::~Event() = default;
void Event::Dump(Stream *s) const {
Broadcaster *broadcaster;
Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock());
if (broadcaster_impl_sp)
broadcaster = broadcaster_impl_sp->GetBroadcaster();
else
broadcaster = nullptr;
if (broadcaster) {
StreamString event_name;
if (broadcaster->GetEventNames(event_name, m_type, false))
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
static_cast<const void *>(this),
static_cast<void *>(broadcaster),
broadcaster->GetBroadcasterName().GetCString(), m_type,
event_name.GetData());
else
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
static_cast<const void *>(this),
static_cast<void *>(broadcaster),
broadcaster->GetBroadcasterName().GetCString(), m_type);
} else
s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
static_cast<const void *>(this), m_type);
if (m_data_sp) {
s->PutChar('{');
m_data_sp->Dump(s);
s->PutChar('}');
} else
s->Printf("<NULL>");
}
void Event::DoOnRemoval() {
if (m_data_sp)
m_data_sp->DoOnRemoval(this);
}
#pragma mark -
#pragma mark EventData
//------------------------------------------------------------------
// EventData functions
//------------------------------------------------------------------
EventData::EventData() = default;
EventData::~EventData() = default;
void EventData::Dump(Stream *s) const { s->PutCString("Generic Event Data"); }
#pragma mark -
#pragma mark EventDataBytes
//------------------------------------------------------------------
// EventDataBytes functions
//------------------------------------------------------------------
EventDataBytes::EventDataBytes() : m_bytes() {}
EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() {
SetBytesFromCString(cstr);
}
EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() {
SetBytes(str.data(), str.size());
}
EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
SetBytes(src, src_len);
}
EventDataBytes::~EventDataBytes() = default;
const ConstString &EventDataBytes::GetFlavorString() {
static ConstString g_flavor("EventDataBytes");
return g_flavor;
}
const ConstString &EventDataBytes::GetFlavor() const {
return EventDataBytes::GetFlavorString();
}
void EventDataBytes::Dump(Stream *s) const {
size_t num_printable_chars =
std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
if (num_printable_chars == m_bytes.size())
s->Format("\"{0}\"", m_bytes);
else
s->Format("{0:$[ ]@[x-2]}", llvm::make_range(
reinterpret_cast<const uint8_t *>(m_bytes.data()),
reinterpret_cast<const uint8_t *>(m_bytes.data() +
m_bytes.size())));
}
const void *EventDataBytes::GetBytes() const {
return (m_bytes.empty() ? nullptr : m_bytes.data());
}
size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); }
void EventDataBytes::SetBytes(const void *src, size_t src_len) {
if (src != nullptr && src_len > 0)
m_bytes.assign((const char *)src, src_len);
else
m_bytes.clear();
}
void EventDataBytes::SetBytesFromCString(const char *cstr) {
if (cstr != nullptr && cstr[0])
m_bytes.assign(cstr);
else
m_bytes.clear();
}
const void *EventDataBytes::GetBytesFromEvent(const Event *event_ptr) {
const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
if (e != nullptr)
return e->GetBytes();
return nullptr;
}
size_t EventDataBytes::GetByteSizeFromEvent(const Event *event_ptr) {
const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
if (e != nullptr)
return e->GetByteSize();
return 0;
}
const EventDataBytes *
EventDataBytes::GetEventDataFromEvent(const Event *event_ptr) {
if (event_ptr != nullptr) {
const EventData *event_data = event_ptr->GetData();
if (event_data &&
event_data->GetFlavor() == EventDataBytes::GetFlavorString())
return static_cast<const EventDataBytes *>(event_data);
}
return nullptr;
}
void EventDataBytes::SwapBytes(std::string &new_bytes) {
m_bytes.swap(new_bytes);
}
#pragma mark -
#pragma mark EventStructuredData
//------------------------------------------------------------------
// EventDataStructuredData definitions
//------------------------------------------------------------------
EventDataStructuredData::EventDataStructuredData()
: EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
EventDataStructuredData::EventDataStructuredData(
const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
const lldb::StructuredDataPluginSP &plugin_sp)
: EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
m_plugin_sp(plugin_sp) {}
EventDataStructuredData::~EventDataStructuredData() {}
//------------------------------------------------------------------
// EventDataStructuredData member functions
//------------------------------------------------------------------
const ConstString &EventDataStructuredData::GetFlavor() const {
return EventDataStructuredData::GetFlavorString();
}
void EventDataStructuredData::Dump(Stream *s) const {
if (!s)
return;
if (m_object_sp)
m_object_sp->Dump(*s);
}
const ProcessSP &EventDataStructuredData::GetProcess() const {
return m_process_sp;
}
const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const {
return m_object_sp;
}
const lldb::StructuredDataPluginSP &
EventDataStructuredData::GetStructuredDataPlugin() const {
return m_plugin_sp;
}
void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) {
m_process_sp = process_sp;
}
void EventDataStructuredData::SetObject(
const StructuredData::ObjectSP &object_sp) {
m_object_sp = object_sp;
}
void EventDataStructuredData::SetStructuredDataPlugin(
const lldb::StructuredDataPluginSP &plugin_sp) {
m_plugin_sp = plugin_sp;
}
//------------------------------------------------------------------
// EventDataStructuredData static functions
//------------------------------------------------------------------
const EventDataStructuredData *
EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr) {
if (event_ptr == nullptr)
return nullptr;
const EventData *event_data = event_ptr->GetData();
if (!event_data ||
event_data->GetFlavor() != EventDataStructuredData::GetFlavorString())
return nullptr;
return static_cast<const EventDataStructuredData *>(event_data);
}
ProcessSP EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr) {
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data)
return event_data->GetProcess();
else
return ProcessSP();
}
StructuredData::ObjectSP
EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr) {
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data)
return event_data->GetObject();
else
return StructuredData::ObjectSP();
}
lldb::StructuredDataPluginSP
EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) {
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data)
return event_data->GetStructuredDataPlugin();
else
return StructuredDataPluginSP();
}
const ConstString &EventDataStructuredData::GetFlavorString() {
static ConstString s_flavor("EventDataStructuredData");
return s_flavor;
}

lldb/trunk/source/Core/Listener.cpp

//===-- Listener.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/Listener.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Event.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "llvm/ADT/Optional.h"
#include <algorithm>
#include <memory>
#include <utility>
using namespace lldb;
using namespace lldb_private;
namespace {
class BroadcasterManagerWPMatcher {
public:
BroadcasterManagerWPMatcher(BroadcasterManagerSP manager_sp)
: m_manager_sp(manager_sp) {}
bool operator()(const BroadcasterManagerWP input_wp) const {
BroadcasterManagerSP input_sp = input_wp.lock();
return (input_sp && input_sp == m_manager_sp);
}
BroadcasterManagerSP m_manager_sp;
};
} // anonymous namespace
Listener::Listener(const char *name)
: m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(),
m_events_mutex() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
if (log != nullptr)
log->Printf("%p Listener::Listener('%s')", static_cast<void *>(this),
m_name.c_str());
}
Listener::~Listener() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
Clear();
if (log)
log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
__FUNCTION__, m_name.c_str());
}
void Listener::Clear() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
broadcaster_collection::iterator pos, end = m_broadcasters.end();
for (pos = m_broadcasters.begin(); pos != end; ++pos) {
Broadcaster::BroadcasterImplSP broadcaster_sp(pos->first.lock());
if (broadcaster_sp)
broadcaster_sp->RemoveListener(this, pos->second.event_mask);
}
m_broadcasters.clear();
std::lock_guard<std::mutex> events_guard(m_events_mutex);
m_events.clear();
size_t num_managers = m_broadcaster_managers.size();
for (size_t i = 0; i < num_managers; i++) {
BroadcasterManagerSP manager_sp(m_broadcaster_managers[i].lock());
if (manager_sp)
manager_sp->RemoveListener(this);
}
if (log)
log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
__FUNCTION__, m_name.c_str());
}
uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask) {
if (broadcaster) {
// Scope for "locker"
// Tell the broadcaster to add this object as a listener
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
m_broadcasters.insert(
std::make_pair(impl_wp, BroadcasterInfo(event_mask)));
}
uint32_t acquired_mask =
broadcaster->AddListener(this->shared_from_this(), event_mask);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log != nullptr)
log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
"mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
static_cast<void *>(this), static_cast<void *>(broadcaster),
event_mask, acquired_mask, m_name.c_str());
return acquired_mask;
}
return 0;
}
uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask,
HandleBroadcastCallback callback,
void *callback_user_data) {
if (broadcaster) {
// Scope for "locker"
// Tell the broadcaster to add this object as a listener
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
m_broadcasters.insert(std::make_pair(
impl_wp, BroadcasterInfo(event_mask, callback, callback_user_data)));
}
uint32_t acquired_mask =
broadcaster->AddListener(this->shared_from_this(), event_mask);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log != nullptr) {
void **pointer = reinterpret_cast<void **>(&callback);
log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
"mask = 0x%8.8x, callback = %p, user_data = %p) "
"acquired_mask = 0x%8.8x for %s",
static_cast<void *>(this), static_cast<void *>(broadcaster),
event_mask, *pointer, static_cast<void *>(callback_user_data),
acquired_mask, m_name.c_str());
}
return acquired_mask;
}
return 0;
}
bool Listener::StopListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask) {
if (broadcaster) {
// Scope for "locker"
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
}
// Remove the broadcaster from our set of broadcasters
return broadcaster->RemoveListener(this->shared_from_this(), event_mask);
}
return false;
}
// Called when a Broadcaster is in its destructor. We need to remove all
// knowledge of this broadcaster and any events that it may have queued up
void Listener::BroadcasterWillDestruct(Broadcaster *broadcaster) {
// Scope for "broadcasters_locker"
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
}
// Scope for "event_locker"
{
std::lock_guard<std::mutex> events_guard(m_events_mutex);
// Remove all events for this broadcaster object.
event_collection::iterator pos = m_events.begin();
while (pos != m_events.end()) {
if ((*pos)->GetBroadcaster() == broadcaster)
pos = m_events.erase(pos);
else
++pos;
}
}
}
void Listener::BroadcasterManagerWillDestruct(BroadcasterManagerSP manager_sp) {
// Just need to remove this broadcast manager from the list of managers:
broadcaster_manager_collection::iterator iter,
end_iter = m_broadcaster_managers.end();
BroadcasterManagerWP manager_wp;
BroadcasterManagerWPMatcher matcher(manager_sp);
iter = std::find_if<broadcaster_manager_collection::iterator,
BroadcasterManagerWPMatcher>(
m_broadcaster_managers.begin(), end_iter, matcher);
if (iter != end_iter)
m_broadcaster_managers.erase(iter);
}
void Listener::AddEvent(EventSP &event_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log != nullptr)
log->Printf("%p Listener('%s')::AddEvent (event_sp = {%p})",
static_cast<void *>(this), m_name.c_str(),
static_cast<void *>(event_sp.get()));
std::lock_guard<std::mutex> guard(m_events_mutex);
m_events.push_back(event_sp);
m_events_condition.notify_all();
}
class EventBroadcasterMatches {
public:
EventBroadcasterMatches(Broadcaster *broadcaster)
: m_broadcaster(broadcaster) {}
bool operator()(const EventSP &event_sp) const {
return event_sp->BroadcasterIs(m_broadcaster);
}
private:
Broadcaster *m_broadcaster;
};
class EventMatcher {
public:
EventMatcher(Broadcaster *broadcaster, const ConstString *broadcaster_names,
uint32_t num_broadcaster_names, uint32_t event_type_mask)
: m_broadcaster(broadcaster), m_broadcaster_names(broadcaster_names),
m_num_broadcaster_names(num_broadcaster_names),
m_event_type_mask(event_type_mask) {}
bool operator()(const EventSP &event_sp) const {
if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
return false;
if (m_broadcaster_names) {
bool found_source = false;
const ConstString &event_broadcaster_name =
event_sp->GetBroadcaster()->GetBroadcasterName();
for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
if (m_broadcaster_names[i] == event_broadcaster_name) {
found_source = true;
break;
}
}
if (!found_source)
return false;
}
if (m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType())
return true;
return false;
}
private:
Broadcaster *m_broadcaster;
const ConstString *m_broadcaster_names;
const uint32_t m_num_broadcaster_names;
const uint32_t m_event_type_mask;
};
bool Listener::FindNextEventInternal(
std::unique_lock<std::mutex> &lock,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *broadcaster_names, // nullptr for any event
uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
bool remove) {
// NOTE: callers of this function must lock m_events_mutex using a
// Mutex::Locker
// and pass the locker as the first argument. m_events_mutex is no longer
// recursive.
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (m_events.empty())
return false;
Listener::event_collection::iterator pos = m_events.end();
if (broadcaster == nullptr && broadcaster_names == nullptr &&
event_type_mask == 0) {
pos = m_events.begin();
} else {
pos = std::find_if(m_events.begin(), m_events.end(),
EventMatcher(broadcaster, broadcaster_names,
num_broadcaster_names, event_type_mask));
}
if (pos != m_events.end()) {
event_sp = *pos;
if (log != nullptr)
log->Printf("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
"broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
"remove=%i) event %p",
static_cast<void *>(this), GetName(),
static_cast<void *>(broadcaster),
static_cast<const void *>(broadcaster_names),
num_broadcaster_names, event_type_mask, remove,
static_cast<void *>(event_sp.get()));
if (remove) {
m_events.erase(pos);
// Unlock the event queue here. We've removed this event and are about
// to return it so it should be okay to get the next event off the queue
// here - and it might be useful to do that in the "DoOnRemoval".
lock.unlock();
event_sp->DoOnRemoval();
}
return true;
}
event_sp.reset();
return false;
}
Event *Listener::PeekAtNextEvent() {
std::unique_lock<std::mutex> guard(m_events_mutex);
EventSP event_sp;
if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp, false))
return event_sp.get();
return nullptr;
}
Event *Listener::PeekAtNextEventForBroadcaster(Broadcaster *broadcaster) {
std::unique_lock<std::mutex> guard(m_events_mutex);
EventSP event_sp;
if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0, event_sp, false))
return event_sp.get();
return nullptr;
}
Event *
Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
uint32_t event_type_mask) {
std::unique_lock<std::mutex> guard(m_events_mutex);
EventSP event_sp;
if (FindNextEventInternal(guard, broadcaster, nullptr, 0, event_type_mask,
event_sp, false))
return event_sp.get();
return nullptr;
}
bool Listener::GetEventInternal(
const Timeout<std::micro> &timeout,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *broadcaster_names, // nullptr for any event
uint32_t num_broadcaster_names, uint32_t event_type_mask,
EventSP &event_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
LLDB_LOG(log, "this = {0}, timeout = {1} for {2}", this, timeout, m_name);
std::unique_lock<std::mutex> lock(m_events_mutex);
while (true) {
if (FindNextEventInternal(lock, broadcaster, broadcaster_names,
num_broadcaster_names, event_type_mask, event_sp,
true)) {
return true;
} else {
std::cv_status result = std::cv_status::no_timeout;
if (!timeout)
m_events_condition.wait(lock);
else
result = m_events_condition.wait_for(lock, *timeout);
if (result == std::cv_status::timeout) {
log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
if (log)
log->Printf("%p Listener::GetEventInternal() timed out for %s",
static_cast<void *>(this), m_name.c_str());
return false;
} else if (result != std::cv_status::no_timeout) {
log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
if (log)
log->Printf("%p Listener::GetEventInternal() unknown error for %s",
static_cast<void *>(this), m_name.c_str());
return false;
}
}
}
return false;
}
bool Listener::GetEventForBroadcasterWithType(
Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp,
const Timeout<std::micro> &timeout) {
return GetEventInternal(timeout, broadcaster, nullptr, 0, event_type_mask,
event_sp);
}
bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
EventSP &event_sp,
const Timeout<std::micro> &timeout) {
return GetEventInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
}
bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) {
return GetEventInternal(timeout, nullptr, nullptr, 0, 0, event_sp);
}
size_t Listener::HandleBroadcastEvent(EventSP &event_sp) {
size_t num_handled = 0;
std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
Broadcaster *broadcaster = event_sp->GetBroadcaster();
if (!broadcaster)
return 0;
broadcaster_collection::iterator pos;
broadcaster_collection::iterator end = m_broadcasters.end();
Broadcaster::BroadcasterImplSP broadcaster_impl_sp(
broadcaster->GetBroadcasterImpl());
for (pos = m_broadcasters.find(broadcaster_impl_sp);
pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) {
BroadcasterInfo info = pos->second;
if (event_sp->GetType() & info.event_mask) {
if (info.callback != nullptr) {
info.callback(event_sp, info.callback_user_data);
++num_handled;
}
}
}
return num_handled;
}
uint32_t
Listener::StartListeningForEventSpec(BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec) {
if (!manager_sp)
return 0;
// The BroadcasterManager mutex must be locked before m_broadcasters_mutex to
// avoid violating the lock hierarchy (manager before broadcasters).
std::lock_guard<std::recursive_mutex> manager_guard(
manager_sp->m_manager_mutex);
std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
this->shared_from_this(), event_spec);
if (bits_acquired) {
broadcaster_manager_collection::iterator iter,
end_iter = m_broadcaster_managers.end();
BroadcasterManagerWP manager_wp(manager_sp);
BroadcasterManagerWPMatcher matcher(manager_sp);
iter = std::find_if<broadcaster_manager_collection::iterator,
BroadcasterManagerWPMatcher>(
m_broadcaster_managers.begin(), end_iter, matcher);
if (iter == end_iter)
m_broadcaster_managers.push_back(manager_wp);
}
return bits_acquired;
}
bool Listener::StopListeningForEventSpec(BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec) {
if (!manager_sp)
return false;
std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),
event_spec);
}
ListenerSP Listener::MakeListener(const char *name) {
return ListenerSP(new Listener(name));
}

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h

Show All 9 Lines
#ifndef liblldb_CommunicationKDP_h_ #ifndef liblldb_CommunicationKDP_h_
#define liblldb_CommunicationKDP_h_ #define liblldb_CommunicationKDP_h_
#include <list> #include <list>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Listener.h"
#include "lldb/Core/StreamBuffer.h" #include "lldb/Core/StreamBuffer.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Predicate.h" #include "lldb/Utility/Predicate.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
class CommunicationKDP : public lldb_private::Communication { class CommunicationKDP : public lldb_private::Communication {
public: public:
enum { eBroadcastBitRunPacketSent = kLoUserBroadcastBit }; enum { eBroadcastBitRunPacketSent = kLoUserBroadcastBit };
const static uint32_t kMaxPacketSize = 1200; const static uint32_t kMaxPacketSize = 1200;
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.h

//===-- ProcessKDP.h --------------------------------------------*- C++ -*-===// //===-- ProcessKDP.h --------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_ProcessKDP_h_ #ifndef liblldb_ProcessKDP_h_
#define liblldb_ProcessKDP_h_ #define liblldb_ProcessKDP_h_
#include <list> #include <list>
#include <vector> #include <vector>
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/ThreadSafeValue.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
#include "CommunicationKDP.h" #include "CommunicationKDP.h"
class ThreadKDP; class ThreadKDP;
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/Utility/HistoryThread.h

//===-- HistoryThread.h -----------------------------------------*- C++ -*-===// //===-- HistoryThread.h -----------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef liblldb_HistoryThread_h_ #ifndef liblldb_HistoryThread_h_
#define liblldb_HistoryThread_h_ #define liblldb_HistoryThread_h_
#include <mutex> #include <mutex>
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/UserSettingsController.h" #include "lldb/Core/UserSettingsController.h"
#include "lldb/Target/ExecutionContextScope.h" #include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/StackFrameList.h" #include "lldb/Target/StackFrameList.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/UserID.h" #include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class HistoryThread HistoryThread.h "HistoryThread.h" /// @class HistoryThread HistoryThread.h "HistoryThread.h"
/// A thread object representing a backtrace from a previous point in the /// A thread object representing a backtrace from a previous point in the
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

Show All 13 Lines
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
#include <queue> #include <queue>
#include <string> #include <string>
#include <vector> #include <vector>
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/Listener.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Utility/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Predicate.h" #include "lldb/Utility/Predicate.h"
#include "lldb/lldb-public.h"
#include "lldb/Utility/StringExtractorGDBRemote.h" #include "lldb/Utility/StringExtractorGDBRemote.h"
#include "lldb/lldb-public.h"
namespace lldb_private { namespace lldb_private {
namespace process_gdb_remote { namespace process_gdb_remote {
typedef enum { typedef enum {
eStoppointInvalid = -1, eStoppointInvalid = -1,
eBreakpointSoftware = 0, eBreakpointSoftware = 0,
eBreakpointHardware, eBreakpointHardware,
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.h

Show All 9 Lines
#ifndef liblldb_GDBRemoteCommunicationReplayServer_h_ #ifndef liblldb_GDBRemoteCommunicationReplayServer_h_
#define liblldb_GDBRemoteCommunicationReplayServer_h_ #define liblldb_GDBRemoteCommunicationReplayServer_h_
// Other libraries and framework includes // Other libraries and framework includes
#include "GDBRemoteCommunication.h" #include "GDBRemoteCommunication.h"
#include "GDBRemoteCommunicationHistory.h" #include "GDBRemoteCommunicationHistory.h"
// Project includes // Project includes
#include "lldb/Core/Broadcaster.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <functional> #include <functional>
#include <map> #include <map>
#include <thread> #include <thread>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.cpp

Show All 13 Lines
#include "GDBRemoteCommunicationReplayServer.h" #include "GDBRemoteCommunicationReplayServer.h"
#include "ProcessGDBRemoteLog.h" #include "ProcessGDBRemoteLog.h"
// C Includes // C Includes
// C++ Includes // C++ Includes
#include <cstring> #include <cstring>
// Project includes // Project includes
#include "lldb/Core/Event.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/StringExtractorGDBRemote.h" #include "lldb/Utility/StringExtractorGDBRemote.h"
using namespace llvm; using namespace llvm;
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::process_gdb_remote; using namespace lldb_private::process_gdb_remote;
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

Show All 10 Lines
#define liblldb_ProcessGDBRemote_h_ #define liblldb_ProcessGDBRemote_h_
#include <atomic> #include <atomic>
#include <map> #include <map>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector> #include <vector>
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/LoadedModuleInfoList.h" #include "lldb/Core/LoadedModuleInfoList.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/ThreadSafeValue.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/ArchSpec.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include "lldb/Utility/StreamGDBRemote.h" #include "lldb/Utility/StreamGDBRemote.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/StringExtractor.h" #include "lldb/Utility/StringExtractor.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-private-forward.h" #include "lldb/lldb-private-forward.h"
▲ Show 20 Lines • Show All 449 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Process.cpp

Show All 11 Lines
#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/Threading.h" #include "llvm/Support/Threading.h"
#include "Plugins/Process/Utility/InferiorCallPOSIX.h" #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Expression/DiagnosticManager.h" #include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/IRDynamicChecks.h" #include "lldb/Expression/IRDynamicChecks.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Expression/UtilityFunction.h" #include "lldb/Expression/UtilityFunction.h"
Show All 28 Lines
#include "lldb/Target/StructuredDataPlugin.h" #include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h" #include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanBase.h" #include "lldb/Target/ThreadPlanBase.h"
#include "lldb/Target/UnixSignals.h" #include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/NameMatches.h" #include "lldb/Utility/NameMatches.h"
#include "lldb/Utility/SelectHelper.h" #include "lldb/Utility/SelectHelper.h"
#include "lldb/Utility/State.h" #include "lldb/Utility/State.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace std::chrono; using namespace std::chrono;
▲ Show 20 Lines • Show All 6,117 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Target.cpp

//===-- Target.cpp ----------------------------------------------*- C++ -*-===// //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <mutex> #include "lldb/Target/Target.h"
#include "Plugins/ExpressionParser/Clang/ClangASTSource.h" #include "Plugins/ExpressionParser/Clang/ClangASTSource.h"
#include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
#include "lldb/Breakpoint/BreakpointIDList.h" #include "lldb/Breakpoint/BreakpointIDList.h"
#include "lldb/Breakpoint/BreakpointResolver.h" #include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Breakpoint/BreakpointResolverAddress.h" #include "lldb/Breakpoint/BreakpointResolverAddress.h"
#include "lldb/Breakpoint/BreakpointResolverFileLine.h" #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
#include "lldb/Breakpoint/BreakpointResolverFileRegex.h" #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
#include "lldb/Breakpoint/BreakpointResolverName.h" #include "lldb/Breakpoint/BreakpointResolverName.h"
#include "lldb/Breakpoint/BreakpointResolverScripted.h" #include "lldb/Breakpoint/BreakpointResolverScripted.h"
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/SourceManager.h" #include "lldb/Core/SourceManager.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StructuredDataImpl.h" #include "lldb/Core/StructuredDataImpl.h"
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
#include "lldb/Expression/REPL.h" #include "lldb/Expression/REPL.h"
#include "lldb/Expression/UserExpression.h" #include "lldb/Expression/UserExpression.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/PosixApi.h" #include "lldb/Host/PosixApi.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionGroupWatchpoint.h" #include "lldb/Interpreter/OptionGroupWatchpoint.h"
#include "lldb/Interpreter/OptionValues.h" #include "lldb/Interpreter/OptionValues.h"
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h" #include "lldb/Symbol/Symbol.h"
#include "lldb/Target/Language.h" #include "lldb/Target/Language.h"
#include "lldb/Target/LanguageRuntime.h" #include "lldb/Target/LanguageRuntime.h"
#include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h" #include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/SystemRuntime.h" #include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadSpec.h" #include "lldb/Target/ThreadSpec.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/LLDBAssert.h" #include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include "lldb/Utility/State.h" #include "lldb/Utility/State.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include "lldb/Utility/Timer.h" #include "lldb/Utility/Timer.h"
#include <mutex>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout; constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout;
Target::Arch::Arch(const ArchSpec &spec) Target::Arch::Arch(const ArchSpec &spec)
: m_spec(spec), : m_spec(spec),
▲ Show 20 Lines • Show All 4,086 Lines • Show Last 20 Lines

lldb/trunk/source/Target/TargetList.cpp

//===-- TargetList.cpp ------------------------------------------*- C++ -*-===// //===-- TargetList.cpp ------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Target/TargetList.h" #include "lldb/Target/TargetList.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/OptionGroupPlatform.h" #include "lldb/Interpreter/OptionGroupPlatform.h"
#include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Platform.h" #include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/State.h" #include "lldb/Utility/State.h"
#include "lldb/Utility/TildeExpressionResolver.h" #include "lldb/Utility/TildeExpressionResolver.h"
#include "lldb/Utility/Timer.h" #include "lldb/Utility/Timer.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
using namespace lldb; using namespace lldb;
▲ Show 20 Lines • Show All 595 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/Broadcaster.cpp

//===-- Broadcaster.cpp -----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include <algorithm>
#include <memory>
#include <type_traits>
#include <assert.h>
#include <stddef.h>
using namespace lldb;
using namespace lldb_private;
Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name)
: m_broadcaster_sp(std::make_shared<BroadcasterImpl>(*this)),
m_manager_sp(manager_sp), m_broadcaster_name(name) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
if (log)
log->Printf("%p Broadcaster::Broadcaster(\"%s\")",
static_cast<void *>(this), GetBroadcasterName().AsCString());
}
Broadcaster::BroadcasterImpl::BroadcasterImpl(Broadcaster &broadcaster)
: m_broadcaster(broadcaster), m_listeners(), m_listeners_mutex(),
m_hijacking_listeners(), m_hijacking_masks() {}
Broadcaster::~Broadcaster() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
if (log)
log->Printf("%p Broadcaster::~Broadcaster(\"%s\")",
static_cast<void *>(this), m_broadcaster_name.AsCString());
Clear();
}
void Broadcaster::CheckInWithManager() {
if (m_manager_sp) {
m_manager_sp->SignUpListenersForBroadcaster(*this);
}
}
llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4>
Broadcaster::BroadcasterImpl::GetListeners() {
llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4> listeners;
listeners.reserve(m_listeners.size());
for (auto it = m_listeners.begin(); it != m_listeners.end();) {
lldb::ListenerSP curr_listener_sp(it->first.lock());
if (curr_listener_sp && it->second) {
listeners.emplace_back(std::move(curr_listener_sp), it->second);
++it;
} else
it = m_listeners.erase(it);
}
return listeners;
}
void Broadcaster::BroadcasterImpl::Clear() {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
// Make sure the listener forgets about this broadcaster. We do this in the
// broadcaster in case the broadcaster object initiates the removal.
for (auto &pair : GetListeners())
pair.first->BroadcasterWillDestruct(&m_broadcaster);
m_listeners.clear();
}
Broadcaster *Broadcaster::BroadcasterImpl::GetBroadcaster() {
return &m_broadcaster;
}
bool Broadcaster::BroadcasterImpl::GetEventNames(
Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const {
uint32_t num_names_added = 0;
if (event_mask && !m_event_names.empty()) {
event_names_map::const_iterator end = m_event_names.end();
for (uint32_t bit = 1u, mask = event_mask; mask != 0 && bit != 0;
bit <<= 1, mask >>= 1) {
if (mask & 1) {
event_names_map::const_iterator pos = m_event_names.find(bit);
if (pos != end) {
if (num_names_added > 0)
s.PutCString(", ");
if (prefix_with_broadcaster_name) {
s.PutCString(GetBroadcasterName());
s.PutChar('.');
}
s.PutCString(pos->second);
++num_names_added;
}
}
}
}
return num_names_added > 0;
}
void Broadcaster::AddInitialEventsToListener(
const lldb::ListenerSP &listener_sp, uint32_t requested_events) {}
uint32_t
Broadcaster::BroadcasterImpl::AddListener(const lldb::ListenerSP &listener_sp,
uint32_t event_mask) {
if (!listener_sp)
return 0;
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
// See if we already have this listener, and if so, update its mask
bool handled = false;
for (auto &pair : GetListeners()) {
if (pair.first == listener_sp) {
handled = true;
pair.second |= event_mask;
m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
break;
}
}
if (!handled) {
// Grant a new listener the available event bits
m_listeners.push_back(
std::make_pair(lldb::ListenerWP(listener_sp), event_mask));
// Individual broadcasters decide whether they have outstanding data when a
// listener attaches, and insert it into the listener with this method.
m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
}
// Return the event bits that were granted to the listener
return event_mask;
}
bool Broadcaster::BroadcasterImpl::EventTypeHasListeners(uint32_t event_type) {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back())
return true;
for (auto &pair : GetListeners()) {
if (pair.second & event_type)
return true;
}
return false;
}
bool Broadcaster::BroadcasterImpl::RemoveListener(
lldb_private::Listener *listener, uint32_t event_mask) {
if (!listener)
return false;
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
for (auto &pair : GetListeners()) {
if (pair.first.get() == listener) {
pair.second &= ~event_mask;
return true;
}
}
return false;
}
bool Broadcaster::BroadcasterImpl::RemoveListener(
const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
return RemoveListener(listener_sp.get(), event_mask);
}
void Broadcaster::BroadcasterImpl::BroadcastEvent(EventSP &event_sp) {
return PrivateBroadcastEvent(event_sp, false);
}
void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(EventSP &event_sp) {
return PrivateBroadcastEvent(event_sp, true);
}
void Broadcaster::BroadcasterImpl::PrivateBroadcastEvent(EventSP &event_sp,
bool unique) {
// Can't add a nullptr event...
if (!event_sp)
return;
// Update the broadcaster on this event
event_sp->SetBroadcaster(&m_broadcaster);
const uint32_t event_type = event_sp->GetType();
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
ListenerSP hijacking_listener_sp;
if (!m_hijacking_listeners.empty()) {
assert(!m_hijacking_masks.empty());
hijacking_listener_sp = m_hijacking_listeners.back();
if ((event_type & m_hijacking_masks.back()) == 0)
hijacking_listener_sp.reset();
}
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log) {
StreamString event_description;
event_sp->Dump(&event_description);
log->Printf("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, "
"unique =%i) hijack = %p",
static_cast<void *>(this), GetBroadcasterName(),
event_description.GetData(), unique,
static_cast<void *>(hijacking_listener_sp.get()));
}
if (hijacking_listener_sp) {
if (unique &&
hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType(
&m_broadcaster, event_type))
return;
hijacking_listener_sp->AddEvent(event_sp);
} else {
for (auto &pair : GetListeners()) {
if (!(pair.second & event_type))
continue;
if (unique &&
pair.first->PeekAtNextEventForBroadcasterWithType(&m_broadcaster,
event_type))
continue;
pair.first->AddEvent(event_sp);
}
}
}
void Broadcaster::BroadcasterImpl::BroadcastEvent(uint32_t event_type,
EventData *event_data) {
auto event_sp = std::make_shared<Event>(event_type, event_data);
PrivateBroadcastEvent(event_sp, false);
}
void Broadcaster::BroadcasterImpl::BroadcastEvent(
uint32_t event_type, const lldb::EventDataSP &event_data_sp) {
auto event_sp = std::make_shared<Event>(event_type, event_data_sp);
PrivateBroadcastEvent(event_sp, false);
}
void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(
uint32_t event_type, EventData *event_data) {
auto event_sp = std::make_shared<Event>(event_type, event_data);
PrivateBroadcastEvent(event_sp, true);
}
bool Broadcaster::BroadcasterImpl::HijackBroadcaster(
const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log)
log->Printf(
"%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
static_cast<void *>(this), GetBroadcasterName(),
listener_sp->m_name.c_str(), static_cast<void *>(listener_sp.get()));
m_hijacking_listeners.push_back(listener_sp);
m_hijacking_masks.push_back(event_mask);
return true;
}
bool Broadcaster::BroadcasterImpl::IsHijackedForEvent(uint32_t event_mask) {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
if (!m_hijacking_listeners.empty())
return (event_mask & m_hijacking_masks.back()) != 0;
return false;
}
const char *Broadcaster::BroadcasterImpl::GetHijackingListenerName() {
if (m_hijacking_listeners.size()) {
return m_hijacking_listeners.back()->GetName();
} else {
return nullptr;
}
}
void Broadcaster::BroadcasterImpl::RestoreBroadcaster() {
std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
if (!m_hijacking_listeners.empty()) {
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log) {
ListenerSP listener_sp = m_hijacking_listeners.back();
log->Printf("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop "
"listener(\"%s\")=%p)",
static_cast<void *>(this), GetBroadcasterName(),
listener_sp->m_name.c_str(),
static_cast<void *>(listener_sp.get()));
}
m_hijacking_listeners.pop_back();
}
if (!m_hijacking_masks.empty())
m_hijacking_masks.pop_back();
}
ConstString &Broadcaster::GetBroadcasterClass() const {
static ConstString class_name("lldb.anonymous");
return class_name;
}
BroadcastEventSpec::BroadcastEventSpec(const BroadcastEventSpec &rhs) = default;
bool BroadcastEventSpec::operator<(const BroadcastEventSpec &rhs) const {
if (GetBroadcasterClass() == rhs.GetBroadcasterClass()) {
return GetEventBits() < rhs.GetEventBits();
} else {
return GetBroadcasterClass() < rhs.GetBroadcasterClass();
}
}
BroadcastEventSpec &BroadcastEventSpec::
operator=(const BroadcastEventSpec &rhs) = default;
BroadcasterManager::BroadcasterManager() : m_manager_mutex() {}
lldb::BroadcasterManagerSP BroadcasterManager::MakeBroadcasterManager() {
return lldb::BroadcasterManagerSP(new BroadcasterManager());
}
uint32_t BroadcasterManager::RegisterListenerForEvents(
const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
uint32_t available_bits = event_spec.GetEventBits();
while (iter != end_iter &&
(iter = find_if(iter, end_iter,
BroadcasterClassMatches(
event_spec.GetBroadcasterClass()))) != end_iter) {
available_bits &= ~((*iter).first.GetEventBits());
iter++;
}
if (available_bits != 0) {
m_event_map.insert(event_listener_key(
BroadcastEventSpec(event_spec.GetBroadcasterClass(), available_bits),
listener_sp));
m_listeners.insert(listener_sp);
}
return available_bits;
}
bool BroadcasterManager::UnregisterListenerForEvents(
const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
bool removed_some = false;
if (m_listeners.erase(listener_sp) == 0)
return false;
ListenerMatchesAndSharedBits predicate(event_spec, listener_sp);
std::vector<BroadcastEventSpec> to_be_readded;
uint32_t event_bits_to_remove = event_spec.GetEventBits();
// Go through the map and delete the exact matches, and build a list of
// matches that weren't exact to re-add:
while (true) {
collection::iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter) {
break;
} else {
uint32_t iter_event_bits = (*iter).first.GetEventBits();
removed_some = true;
if (event_bits_to_remove != iter_event_bits) {
uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
to_be_readded.push_back(BroadcastEventSpec(
event_spec.GetBroadcasterClass(), new_event_bits));
}
m_event_map.erase(iter);
}
}
// Okay now add back the bits that weren't completely removed:
for (size_t i = 0; i < to_be_readded.size(); i++) {
m_event_map.insert(event_listener_key(to_be_readded[i], listener_sp));
}
return removed_some;
}
ListenerSP BroadcasterManager::GetListenerForEventSpec(
BroadcastEventSpec event_spec) const {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
collection::const_iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter,
BroadcastEventSpecMatches(event_spec));
if (iter != end_iter)
return (*iter).second;
else
return nullptr;
}
void BroadcasterManager::RemoveListener(Listener *listener) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
ListenerMatchesPointer predicate(listener);
listener_collection::iterator iter = m_listeners.begin(),
end_iter = m_listeners.end();
std::find_if(iter, end_iter, predicate);
if (iter != end_iter)
m_listeners.erase(iter);
while (true) {
collection::iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter)
break;
else
m_event_map.erase(iter);
}
}
void BroadcasterManager::RemoveListener(const lldb::ListenerSP &listener_sp) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
ListenerMatches predicate(listener_sp);
if (m_listeners.erase(listener_sp) == 0)
return;
while (true) {
collection::iterator iter, end_iter = m_event_map.end();
iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter)
break;
else
m_event_map.erase(iter);
}
}
void BroadcasterManager::SignUpListenersForBroadcaster(
Broadcaster &broadcaster) {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
while (iter != end_iter &&
(iter = find_if(iter, end_iter,
BroadcasterClassMatches(
broadcaster.GetBroadcasterClass()))) != end_iter) {
(*iter).second->StartListeningForEvents(&broadcaster,
(*iter).first.GetEventBits());
iter++;
}
}
void BroadcasterManager::Clear() {
std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
listener_collection::iterator end_iter = m_listeners.end();
for (listener_collection::iterator iter = m_listeners.begin();
iter != end_iter; iter++)
(*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());
m_listeners.clear();
m_event_map.clear();
}

lldb/trunk/source/Utility/CMakeLists.txt

Show All 39 Lines if (NOT LLDB_DISABLE_CURSES)
list(APPEND LLDB_SYSTEM_LIBS gpm) list(APPEND LLDB_SYSTEM_LIBS gpm)
endif() endif()
endif() endif()
add_lldb_library(lldbUtility add_lldb_library(lldbUtility
ArchSpec.cpp ArchSpec.cpp
Args.cpp Args.cpp
Baton.cpp Baton.cpp
Broadcaster.cpp
Connection.cpp Connection.cpp
ConstString.cpp ConstString.cpp
CompletionRequest.cpp CompletionRequest.cpp
DataBufferHeap.cpp DataBufferHeap.cpp
DataBufferLLVM.cpp DataBufferLLVM.cpp
DataEncoder.cpp DataEncoder.cpp
DataExtractor.cpp DataExtractor.cpp
Environment.cpp Environment.cpp
Event.cpp
FileSpec.cpp FileSpec.cpp
IOObject.cpp IOObject.cpp
JSON.cpp JSON.cpp
LLDBAssert.cpp LLDBAssert.cpp
Listener.cpp
Log.cpp Log.cpp
Logging.cpp Logging.cpp
NameMatches.cpp NameMatches.cpp
Range.cpp Range.cpp
RegisterValue.cpp RegisterValue.cpp
RegularExpression.cpp RegularExpression.cpp
Reproducer.cpp Reproducer.cpp
Scalar.cpp Scalar.cpp
Show All 29 Lines

lldb/trunk/source/Utility/Event.cpp

//===-- Event.cpp -----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-enumerations.h"
#include <algorithm>
#include <ctype.h>
using namespace lldb;
using namespace lldb_private;
#pragma mark -
#pragma mark Event
//------------------------------------------------------------------
// Event functions
//------------------------------------------------------------------
Event::Event(Broadcaster *broadcaster, uint32_t event_type, EventData *data)
: m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
m_data_sp(data) {}
Event::Event(Broadcaster *broadcaster, uint32_t event_type,
const EventDataSP &event_data_sp)
: m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
m_data_sp(event_data_sp) {}
Event::Event(uint32_t event_type, EventData *data)
: m_broadcaster_wp(), m_type(event_type), m_data_sp(data) {}
Event::Event(uint32_t event_type, const EventDataSP &event_data_sp)
: m_broadcaster_wp(), m_type(event_type), m_data_sp(event_data_sp) {}
Event::~Event() = default;
void Event::Dump(Stream *s) const {
Broadcaster *broadcaster;
Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock());
if (broadcaster_impl_sp)
broadcaster = broadcaster_impl_sp->GetBroadcaster();
else
broadcaster = nullptr;
if (broadcaster) {
StreamString event_name;
if (broadcaster->GetEventNames(event_name, m_type, false))
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
static_cast<const void *>(this),
static_cast<void *>(broadcaster),
broadcaster->GetBroadcasterName().GetCString(), m_type,
event_name.GetData());
else
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
static_cast<const void *>(this),
static_cast<void *>(broadcaster),
broadcaster->GetBroadcasterName().GetCString(), m_type);
} else
s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
static_cast<const void *>(this), m_type);
if (m_data_sp) {
s->PutChar('{');
m_data_sp->Dump(s);
s->PutChar('}');
} else
s->Printf("<NULL>");
}
void Event::DoOnRemoval() {
if (m_data_sp)
m_data_sp->DoOnRemoval(this);
}
#pragma mark -
#pragma mark EventData
//------------------------------------------------------------------
// EventData functions
//------------------------------------------------------------------
EventData::EventData() = default;
EventData::~EventData() = default;
void EventData::Dump(Stream *s) const { s->PutCString("Generic Event Data"); }
#pragma mark -
#pragma mark EventDataBytes
//------------------------------------------------------------------
// EventDataBytes functions
//------------------------------------------------------------------
EventDataBytes::EventDataBytes() : m_bytes() {}
EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() {
SetBytesFromCString(cstr);
}
EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() {
SetBytes(str.data(), str.size());
}
EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
SetBytes(src, src_len);
}
EventDataBytes::~EventDataBytes() = default;
const ConstString &EventDataBytes::GetFlavorString() {
static ConstString g_flavor("EventDataBytes");
return g_flavor;
}
const ConstString &EventDataBytes::GetFlavor() const {
return EventDataBytes::GetFlavorString();
}
void EventDataBytes::Dump(Stream *s) const {
size_t num_printable_chars =
std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
if (num_printable_chars == m_bytes.size())
s->Format("\"{0}\"", m_bytes);
else
s->Format("{0:$[ ]@[x-2]}", llvm::make_range(
reinterpret_cast<const uint8_t *>(m_bytes.data()),
reinterpret_cast<const uint8_t *>(m_bytes.data() +
m_bytes.size())));
}
const void *EventDataBytes::GetBytes() const {
return (m_bytes.empty() ? nullptr : m_bytes.data());
}
size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); }
void EventDataBytes::SetBytes(const void *src, size_t src_len) {
if (src != nullptr && src_len > 0)
m_bytes.assign((const char *)src, src_len);
else
m_bytes.clear();
}
void EventDataBytes::SetBytesFromCString(const char *cstr) {
if (cstr != nullptr && cstr[0])
m_bytes.assign(cstr);
else
m_bytes.clear();
}
const void *EventDataBytes::GetBytesFromEvent(const Event *event_ptr) {
const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
if (e != nullptr)
return e->GetBytes();
return nullptr;
}
size_t EventDataBytes::GetByteSizeFromEvent(const Event *event_ptr) {
const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
if (e != nullptr)
return e->GetByteSize();
return 0;
}
const EventDataBytes *
EventDataBytes::GetEventDataFromEvent(const Event *event_ptr) {
if (event_ptr != nullptr) {
const EventData *event_data = event_ptr->GetData();
if (event_data &&
event_data->GetFlavor() == EventDataBytes::GetFlavorString())
return static_cast<const EventDataBytes *>(event_data);
}
return nullptr;
}
void EventDataBytes::SwapBytes(std::string &new_bytes) {
m_bytes.swap(new_bytes);
}
#pragma mark -
#pragma mark EventStructuredData
//------------------------------------------------------------------
// EventDataStructuredData definitions
//------------------------------------------------------------------
EventDataStructuredData::EventDataStructuredData()
: EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
EventDataStructuredData::EventDataStructuredData(
const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
const lldb::StructuredDataPluginSP &plugin_sp)
: EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
m_plugin_sp(plugin_sp) {}
EventDataStructuredData::~EventDataStructuredData() {}
//------------------------------------------------------------------
// EventDataStructuredData member functions
//------------------------------------------------------------------
const ConstString &EventDataStructuredData::GetFlavor() const {
return EventDataStructuredData::GetFlavorString();
}
void EventDataStructuredData::Dump(Stream *s) const {
if (!s)
return;
if (m_object_sp)
m_object_sp->Dump(*s);
}
const ProcessSP &EventDataStructuredData::GetProcess() const {
return m_process_sp;
}
const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const {
return m_object_sp;
}
const lldb::StructuredDataPluginSP &
EventDataStructuredData::GetStructuredDataPlugin() const {
return m_plugin_sp;
}
void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) {
m_process_sp = process_sp;
}
void EventDataStructuredData::SetObject(
const StructuredData::ObjectSP &object_sp) {
m_object_sp = object_sp;
}
void EventDataStructuredData::SetStructuredDataPlugin(
const lldb::StructuredDataPluginSP &plugin_sp) {
m_plugin_sp = plugin_sp;
}
//------------------------------------------------------------------
// EventDataStructuredData static functions
//------------------------------------------------------------------
const EventDataStructuredData *
EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr) {
if (event_ptr == nullptr)
return nullptr;
const EventData *event_data = event_ptr->GetData();
if (!event_data ||
event_data->GetFlavor() != EventDataStructuredData::GetFlavorString())
return nullptr;
return static_cast<const EventDataStructuredData *>(event_data);
}
ProcessSP EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr) {
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data)
return event_data->GetProcess();
else
return ProcessSP();
}
StructuredData::ObjectSP
EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr) {
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data)
return event_data->GetObject();
else
return StructuredData::ObjectSP();
}
lldb::StructuredDataPluginSP
EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) {
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data)
return event_data->GetStructuredDataPlugin();
else
return StructuredDataPluginSP();
}
const ConstString &EventDataStructuredData::GetFlavorString() {
static ConstString s_flavor("EventDataStructuredData");
return s_flavor;
}

lldb/trunk/source/Utility/Listener.cpp

//===-- Listener.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "llvm/ADT/Optional.h"
#include <algorithm>
#include <memory>
#include <utility>
using namespace lldb;
using namespace lldb_private;
namespace {
class BroadcasterManagerWPMatcher {
public:
BroadcasterManagerWPMatcher(BroadcasterManagerSP manager_sp)
: m_manager_sp(manager_sp) {}
bool operator()(const BroadcasterManagerWP input_wp) const {
BroadcasterManagerSP input_sp = input_wp.lock();
return (input_sp && input_sp == m_manager_sp);
}
BroadcasterManagerSP m_manager_sp;
};
} // anonymous namespace
Listener::Listener(const char *name)
: m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(),
m_events_mutex() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
if (log != nullptr)
log->Printf("%p Listener::Listener('%s')", static_cast<void *>(this),
m_name.c_str());
}
Listener::~Listener() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
Clear();
if (log)
log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
__FUNCTION__, m_name.c_str());
}
void Listener::Clear() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
broadcaster_collection::iterator pos, end = m_broadcasters.end();
for (pos = m_broadcasters.begin(); pos != end; ++pos) {
Broadcaster::BroadcasterImplSP broadcaster_sp(pos->first.lock());
if (broadcaster_sp)
broadcaster_sp->RemoveListener(this, pos->second.event_mask);
}
m_broadcasters.clear();
std::lock_guard<std::mutex> events_guard(m_events_mutex);
m_events.clear();
size_t num_managers = m_broadcaster_managers.size();
for (size_t i = 0; i < num_managers; i++) {
BroadcasterManagerSP manager_sp(m_broadcaster_managers[i].lock());
if (manager_sp)
manager_sp->RemoveListener(this);
}
if (log)
log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
__FUNCTION__, m_name.c_str());
}
uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask) {
if (broadcaster) {
// Scope for "locker"
// Tell the broadcaster to add this object as a listener
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
m_broadcasters.insert(
std::make_pair(impl_wp, BroadcasterInfo(event_mask)));
}
uint32_t acquired_mask =
broadcaster->AddListener(this->shared_from_this(), event_mask);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log != nullptr)
log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
"mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
static_cast<void *>(this), static_cast<void *>(broadcaster),
event_mask, acquired_mask, m_name.c_str());
return acquired_mask;
}
return 0;
}
uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask,
HandleBroadcastCallback callback,
void *callback_user_data) {
if (broadcaster) {
// Scope for "locker"
// Tell the broadcaster to add this object as a listener
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
m_broadcasters.insert(std::make_pair(
impl_wp, BroadcasterInfo(event_mask, callback, callback_user_data)));
}
uint32_t acquired_mask =
broadcaster->AddListener(this->shared_from_this(), event_mask);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log != nullptr) {
void **pointer = reinterpret_cast<void **>(&callback);
log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
"mask = 0x%8.8x, callback = %p, user_data = %p) "
"acquired_mask = 0x%8.8x for %s",
static_cast<void *>(this), static_cast<void *>(broadcaster),
event_mask, *pointer, static_cast<void *>(callback_user_data),
acquired_mask, m_name.c_str());
}
return acquired_mask;
}
return 0;
}
bool Listener::StopListeningForEvents(Broadcaster *broadcaster,
uint32_t event_mask) {
if (broadcaster) {
// Scope for "locker"
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
}
// Remove the broadcaster from our set of broadcasters
return broadcaster->RemoveListener(this->shared_from_this(), event_mask);
}
return false;
}
// Called when a Broadcaster is in its destructor. We need to remove all
// knowledge of this broadcaster and any events that it may have queued up
void Listener::BroadcasterWillDestruct(Broadcaster *broadcaster) {
// Scope for "broadcasters_locker"
{
std::lock_guard<std::recursive_mutex> broadcasters_guard(
m_broadcasters_mutex);
m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
}
// Scope for "event_locker"
{
std::lock_guard<std::mutex> events_guard(m_events_mutex);
// Remove all events for this broadcaster object.
event_collection::iterator pos = m_events.begin();
while (pos != m_events.end()) {
if ((*pos)->GetBroadcaster() == broadcaster)
pos = m_events.erase(pos);
else
++pos;
}
}
}
void Listener::BroadcasterManagerWillDestruct(BroadcasterManagerSP manager_sp) {
// Just need to remove this broadcast manager from the list of managers:
broadcaster_manager_collection::iterator iter,
end_iter = m_broadcaster_managers.end();
BroadcasterManagerWP manager_wp;
BroadcasterManagerWPMatcher matcher(manager_sp);
iter = std::find_if<broadcaster_manager_collection::iterator,
BroadcasterManagerWPMatcher>(
m_broadcaster_managers.begin(), end_iter, matcher);
if (iter != end_iter)
m_broadcaster_managers.erase(iter);
}
void Listener::AddEvent(EventSP &event_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log != nullptr)
log->Printf("%p Listener('%s')::AddEvent (event_sp = {%p})",
static_cast<void *>(this), m_name.c_str(),
static_cast<void *>(event_sp.get()));
std::lock_guard<std::mutex> guard(m_events_mutex);
m_events.push_back(event_sp);
m_events_condition.notify_all();
}
class EventBroadcasterMatches {
public:
EventBroadcasterMatches(Broadcaster *broadcaster)
: m_broadcaster(broadcaster) {}
bool operator()(const EventSP &event_sp) const {
return event_sp->BroadcasterIs(m_broadcaster);
}
private:
Broadcaster *m_broadcaster;
};
class EventMatcher {
public:
EventMatcher(Broadcaster *broadcaster, const ConstString *broadcaster_names,
uint32_t num_broadcaster_names, uint32_t event_type_mask)
: m_broadcaster(broadcaster), m_broadcaster_names(broadcaster_names),
m_num_broadcaster_names(num_broadcaster_names),
m_event_type_mask(event_type_mask) {}
bool operator()(const EventSP &event_sp) const {
if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
return false;
if (m_broadcaster_names) {
bool found_source = false;
const ConstString &event_broadcaster_name =
event_sp->GetBroadcaster()->GetBroadcasterName();
for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
if (m_broadcaster_names[i] == event_broadcaster_name) {
found_source = true;
break;
}
}
if (!found_source)
return false;
}
if (m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType())
return true;
return false;
}
private:
Broadcaster *m_broadcaster;
const ConstString *m_broadcaster_names;
const uint32_t m_num_broadcaster_names;
const uint32_t m_event_type_mask;
};
bool Listener::FindNextEventInternal(
std::unique_lock<std::mutex> &lock,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *broadcaster_names, // nullptr for any event
uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
bool remove) {
// NOTE: callers of this function must lock m_events_mutex using a
// Mutex::Locker
// and pass the locker as the first argument. m_events_mutex is no longer
// recursive.
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (m_events.empty())
return false;
Listener::event_collection::iterator pos = m_events.end();
if (broadcaster == nullptr && broadcaster_names == nullptr &&
event_type_mask == 0) {
pos = m_events.begin();
} else {
pos = std::find_if(m_events.begin(), m_events.end(),
EventMatcher(broadcaster, broadcaster_names,
num_broadcaster_names, event_type_mask));
}
if (pos != m_events.end()) {
event_sp = *pos;
if (log != nullptr)
log->Printf("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
"broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
"remove=%i) event %p",
static_cast<void *>(this), GetName(),
static_cast<void *>(broadcaster),
static_cast<const void *>(broadcaster_names),
num_broadcaster_names, event_type_mask, remove,
static_cast<void *>(event_sp.get()));
if (remove) {
m_events.erase(pos);
// Unlock the event queue here. We've removed this event and are about
// to return it so it should be okay to get the next event off the queue
// here - and it might be useful to do that in the "DoOnRemoval".
lock.unlock();
event_sp->DoOnRemoval();
}
return true;
}
event_sp.reset();
return false;
}
Event *Listener::PeekAtNextEvent() {
std::unique_lock<std::mutex> guard(m_events_mutex);
EventSP event_sp;
if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp, false))
return event_sp.get();
return nullptr;
}
Event *Listener::PeekAtNextEventForBroadcaster(Broadcaster *broadcaster) {
std::unique_lock<std::mutex> guard(m_events_mutex);
EventSP event_sp;
if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0, event_sp, false))
return event_sp.get();
return nullptr;
}
Event *
Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
uint32_t event_type_mask) {
std::unique_lock<std::mutex> guard(m_events_mutex);
EventSP event_sp;
if (FindNextEventInternal(guard, broadcaster, nullptr, 0, event_type_mask,
event_sp, false))
return event_sp.get();
return nullptr;
}
bool Listener::GetEventInternal(
const Timeout<std::micro> &timeout,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *broadcaster_names, // nullptr for any event
uint32_t num_broadcaster_names, uint32_t event_type_mask,
EventSP &event_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
LLDB_LOG(log, "this = {0}, timeout = {1} for {2}", this, timeout, m_name);
std::unique_lock<std::mutex> lock(m_events_mutex);
while (true) {
if (FindNextEventInternal(lock, broadcaster, broadcaster_names,
num_broadcaster_names, event_type_mask, event_sp,
true)) {
return true;
} else {
std::cv_status result = std::cv_status::no_timeout;
if (!timeout)
m_events_condition.wait(lock);
else
result = m_events_condition.wait_for(lock, *timeout);
if (result == std::cv_status::timeout) {
log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
if (log)
log->Printf("%p Listener::GetEventInternal() timed out for %s",
static_cast<void *>(this), m_name.c_str());
return false;
} else if (result != std::cv_status::no_timeout) {
log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
if (log)
log->Printf("%p Listener::GetEventInternal() unknown error for %s",
static_cast<void *>(this), m_name.c_str());
return false;
}
}
}
return false;
}
bool Listener::GetEventForBroadcasterWithType(
Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp,
const Timeout<std::micro> &timeout) {
return GetEventInternal(timeout, broadcaster, nullptr, 0, event_type_mask,
event_sp);
}
bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
EventSP &event_sp,
const Timeout<std::micro> &timeout) {
return GetEventInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
}
bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) {
return GetEventInternal(timeout, nullptr, nullptr, 0, 0, event_sp);
}
size_t Listener::HandleBroadcastEvent(EventSP &event_sp) {
size_t num_handled = 0;
std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
Broadcaster *broadcaster = event_sp->GetBroadcaster();
if (!broadcaster)
return 0;
broadcaster_collection::iterator pos;
broadcaster_collection::iterator end = m_broadcasters.end();
Broadcaster::BroadcasterImplSP broadcaster_impl_sp(
broadcaster->GetBroadcasterImpl());
for (pos = m_broadcasters.find(broadcaster_impl_sp);
pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) {
BroadcasterInfo info = pos->second;
if (event_sp->GetType() & info.event_mask) {
if (info.callback != nullptr) {
info.callback(event_sp, info.callback_user_data);
++num_handled;
}
}
}
return num_handled;
}
uint32_t
Listener::StartListeningForEventSpec(BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec) {
if (!manager_sp)
return 0;
// The BroadcasterManager mutex must be locked before m_broadcasters_mutex to
// avoid violating the lock hierarchy (manager before broadcasters).
std::lock_guard<std::recursive_mutex> manager_guard(
manager_sp->m_manager_mutex);
std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
this->shared_from_this(), event_spec);
if (bits_acquired) {
broadcaster_manager_collection::iterator iter,
end_iter = m_broadcaster_managers.end();
BroadcasterManagerWP manager_wp(manager_sp);
BroadcasterManagerWPMatcher matcher(manager_sp);
iter = std::find_if<broadcaster_manager_collection::iterator,
BroadcasterManagerWPMatcher>(
m_broadcaster_managers.begin(), end_iter, matcher);
if (iter == end_iter)
m_broadcaster_managers.push_back(manager_wp);
}
return bits_acquired;
}
bool Listener::StopListeningForEventSpec(BroadcasterManagerSP manager_sp,
const BroadcastEventSpec &event_spec) {
if (!manager_sp)
return false;
std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),
event_spec);
}
ListenerSP Listener::MakeListener(const char *name) {
return ListenerSP(new Listener(name));
}

lldb/trunk/unittests/Core/BroadcasterTest.cpp

//===-- BroadcasterTest.cpp -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Listener.h"
#include "lldb/Utility/Predicate.h"
#include <thread>
using namespace lldb;
using namespace lldb_private;
TEST(BroadcasterTest, BroadcastEvent) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
std::chrono::seconds timeout(0);
// Create a listener, sign it up, make sure it receives an event.
ListenerSP listener1_sp = Listener::MakeListener("test-listener1");
const uint32_t event_mask1 = 1;
EXPECT_EQ(event_mask1,
listener1_sp->StartListeningForEvents(&broadcaster, event_mask1));
broadcaster.BroadcastEvent(event_mask1, nullptr);
EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask1, event_sp->GetType());
{
// Add one more listener, make sure it works as well.
ListenerSP listener2_sp = Listener::MakeListener("test-listener2");
const uint32_t event_mask2 = 1;
EXPECT_EQ(event_mask2, listener2_sp->StartListeningForEvents(
&broadcaster, event_mask1 | event_mask2));
broadcaster.BroadcastEvent(event_mask2, nullptr);
EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask2, event_sp->GetType());
// Both listeners should get this event.
broadcaster.BroadcastEvent(event_mask1, nullptr);
EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask1, event_sp->GetType());
EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask2, event_sp->GetType());
}
// Now again only one listener should be active.
broadcaster.BroadcastEvent(event_mask1, nullptr);
EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask1, event_sp->GetType());
}
TEST(BroadcasterTest, EventTypeHasListeners) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
const uint32_t event_mask = 1;
EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
{
ListenerSP listener_sp = Listener::MakeListener("test-listener");
EXPECT_EQ(event_mask,
listener_sp->StartListeningForEvents(&broadcaster, event_mask));
EXPECT_TRUE(broadcaster.EventTypeHasListeners(event_mask));
}
EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
}

lldb/trunk/unittests/Core/CMakeLists.txt

add_lldb_unittest(LLDBCoreTests add_lldb_unittest(LLDBCoreTests
BroadcasterTest.cpp
EventTest.cpp
ListenerTest.cpp
MangledTest.cpp MangledTest.cpp
RangeTest.cpp RangeTest.cpp
RichManglingContextTest.cpp RichManglingContextTest.cpp
StreamCallbackTest.cpp StreamCallbackTest.cpp
LINK_LIBS LINK_LIBS
lldbCore lldbCore
lldbHost lldbHost
Show All 15 Lines

lldb/trunk/unittests/Core/EventTest.cpp

//===-- EventTest.cpp -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Core/Event.h"
#include "lldb/Utility/StreamString.h"
#include "gtest/gtest.h"
using namespace lldb_private;
static std::string to_string(const EventDataBytes &E) {
StreamString S;
E.Dump(&S);
return S.GetString();
}
TEST(EventTest, DumpEventDataBytes) {
EXPECT_EQ(R"("foo")", to_string(EventDataBytes("foo")));
EXPECT_EQ("01 02 03", to_string(EventDataBytes("\x01\x02\x03")));
}

lldb/trunk/unittests/Core/ListenerTest.cpp

//===-- ListenerTest.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Core/Listener.h"
#include <future>
#include <thread>
using namespace lldb;
using namespace lldb_private;
TEST(ListenerTest, GetEventImmediate) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
// Create a listener, sign it up, make sure it receives an event.
ListenerSP listener_sp = Listener::MakeListener("test-listener");
const uint32_t event_mask = 1;
ASSERT_EQ(event_mask,
listener_sp->StartListeningForEvents(&broadcaster, event_mask));
const std::chrono::seconds timeout(0);
// Without any events sent, these should return false.
EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
EXPECT_FALSE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
// Now send events and make sure they get it.
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask * 2, event_sp, timeout));
EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
}
TEST(ListenerTest, GetEventWait) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
// Create a listener, sign it up, make sure it receives an event.
ListenerSP listener_sp = Listener::MakeListener("test-listener");
const uint32_t event_mask = 1;
ASSERT_EQ(event_mask,
listener_sp->StartListeningForEvents(&broadcaster, event_mask));
// Without any events sent, these should make a short wait and return false.
std::chrono::microseconds timeout(10);
EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
EXPECT_FALSE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
// Now send events and make sure they get it.
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask * 2, event_sp, timeout));
EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
auto delayed_broadcast = [&] {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
broadcaster.BroadcastEvent(event_mask, nullptr);
};
// These should do an infinite wait at return the event our asynchronous
// broadcast sends.
std::future<void> async_broadcast =
std::async(std::launch::async, delayed_broadcast);
EXPECT_TRUE(listener_sp->GetEvent(event_sp, llvm::None));
async_broadcast.get();
async_broadcast = std::async(std::launch::async, delayed_broadcast);
EXPECT_TRUE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, llvm::None));
async_broadcast.get();
async_broadcast = std::async(std::launch::async, delayed_broadcast);
EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, llvm::None));
async_broadcast.get();
}

lldb/trunk/unittests/Utility/BroadcasterTest.cpp

//===-- BroadcasterTest.cpp -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Predicate.h"
#include <thread>
using namespace lldb;
using namespace lldb_private;
TEST(BroadcasterTest, BroadcastEvent) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
std::chrono::seconds timeout(0);
// Create a listener, sign it up, make sure it receives an event.
ListenerSP listener1_sp = Listener::MakeListener("test-listener1");
const uint32_t event_mask1 = 1;
EXPECT_EQ(event_mask1,
listener1_sp->StartListeningForEvents(&broadcaster, event_mask1));
broadcaster.BroadcastEvent(event_mask1, nullptr);
EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask1, event_sp->GetType());
{
// Add one more listener, make sure it works as well.
ListenerSP listener2_sp = Listener::MakeListener("test-listener2");
const uint32_t event_mask2 = 1;
EXPECT_EQ(event_mask2, listener2_sp->StartListeningForEvents(
&broadcaster, event_mask1 | event_mask2));
broadcaster.BroadcastEvent(event_mask2, nullptr);
EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask2, event_sp->GetType());
// Both listeners should get this event.
broadcaster.BroadcastEvent(event_mask1, nullptr);
EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask1, event_sp->GetType());
EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask2, event_sp->GetType());
}
// Now again only one listener should be active.
broadcaster.BroadcastEvent(event_mask1, nullptr);
EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
EXPECT_EQ(event_mask1, event_sp->GetType());
}
TEST(BroadcasterTest, EventTypeHasListeners) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
const uint32_t event_mask = 1;
EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
{
ListenerSP listener_sp = Listener::MakeListener("test-listener");
EXPECT_EQ(event_mask,
listener_sp->StartListeningForEvents(&broadcaster, event_mask));
EXPECT_TRUE(broadcaster.EventTypeHasListeners(event_mask));
}
EXPECT_FALSE(broadcaster.EventTypeHasListeners(event_mask));
}

lldb/trunk/unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests add_lldb_unittest(UtilityTests
AnsiTerminalTest.cpp AnsiTerminalTest.cpp
ArgsTest.cpp ArgsTest.cpp
OptionsWithRawTest.cpp OptionsWithRawTest.cpp
ArchSpecTest.cpp ArchSpecTest.cpp
BroadcasterTest.cpp
CleanUpTest.cpp CleanUpTest.cpp
ConstStringTest.cpp ConstStringTest.cpp
CompletionRequestTest.cpp CompletionRequestTest.cpp
DataExtractorTest.cpp DataExtractorTest.cpp
EnvironmentTest.cpp EnvironmentTest.cpp
EventTest.cpp
FileSpecTest.cpp FileSpecTest.cpp
FlagsTest.cpp FlagsTest.cpp
JSONTest.cpp JSONTest.cpp
ListenerTest.cpp
LogTest.cpp LogTest.cpp
NameMatchesTest.cpp NameMatchesTest.cpp
PredicateTest.cpp PredicateTest.cpp
RegisterValueTest.cpp RegisterValueTest.cpp
ReproducerTest.cpp ReproducerTest.cpp
ScalarTest.cpp ScalarTest.cpp
StateTest.cpp StateTest.cpp
StatusTest.cpp StatusTest.cpp
Show All 25 Lines

lldb/trunk/unittests/Utility/EventTest.cpp

//===-- EventTest.cpp -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/Event.h"
#include "lldb/Utility/StreamString.h"
#include "gtest/gtest.h"
using namespace lldb_private;
static std::string to_string(const EventDataBytes &E) {
StreamString S;
E.Dump(&S);
return S.GetString();
}
TEST(EventTest, DumpEventDataBytes) {
EXPECT_EQ(R"("foo")", to_string(EventDataBytes("foo")));
EXPECT_EQ("01 02 03", to_string(EventDataBytes("\x01\x02\x03")));
}

lldb/trunk/unittests/Utility/ListenerTest.cpp

//===-- ListenerTest.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Listener.h"
#include <future>
#include <thread>
using namespace lldb;
using namespace lldb_private;
TEST(ListenerTest, GetEventImmediate) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
// Create a listener, sign it up, make sure it receives an event.
ListenerSP listener_sp = Listener::MakeListener("test-listener");
const uint32_t event_mask = 1;
ASSERT_EQ(event_mask,
listener_sp->StartListeningForEvents(&broadcaster, event_mask));
const std::chrono::seconds timeout(0);
// Without any events sent, these should return false.
EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
EXPECT_FALSE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
// Now send events and make sure they get it.
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask * 2, event_sp, timeout));
EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
}
TEST(ListenerTest, GetEventWait) {
EventSP event_sp;
Broadcaster broadcaster(nullptr, "test-broadcaster");
// Create a listener, sign it up, make sure it receives an event.
ListenerSP listener_sp = Listener::MakeListener("test-listener");
const uint32_t event_mask = 1;
ASSERT_EQ(event_mask,
listener_sp->StartListeningForEvents(&broadcaster, event_mask));
// Without any events sent, these should make a short wait and return false.
std::chrono::microseconds timeout(10);
EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
EXPECT_FALSE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
// Now send events and make sure they get it.
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_TRUE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
broadcaster.BroadcastEvent(event_mask, nullptr);
EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask * 2, event_sp, timeout));
EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, timeout));
auto delayed_broadcast = [&] {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
broadcaster.BroadcastEvent(event_mask, nullptr);
};
// These should do an infinite wait at return the event our asynchronous
// broadcast sends.
std::future<void> async_broadcast =
std::async(std::launch::async, delayed_broadcast);
EXPECT_TRUE(listener_sp->GetEvent(event_sp, llvm::None));
async_broadcast.get();
async_broadcast = std::async(std::launch::async, delayed_broadcast);
EXPECT_TRUE(
listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, llvm::None));
async_broadcast.get();
async_broadcast = std::async(std::launch::async, delayed_broadcast);
EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
&broadcaster, event_mask, event_sp, llvm::None));
async_broadcast.get();
}
lldb/trunk/unittests/Core/CMakeLists.txt