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

   1 //===-- Event.cpp -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/Event.h"
  11
  12 #include "lldb/Core/Broadcaster.h"
  13 #include "lldb/Utility/DataExtractor.h"
  14 #include "lldb/Utility/Endian.h"
  15 #include "lldb/Utility/Stream.h"
  16 #include "lldb/Utility/StreamString.h" // for StreamString
  17 #include "lldb/lldb-enumerations.h"    // for Format::eFormatBytes
  18
  19 #include <algorithm>
  20
  21 #include <ctype.h> // for isprint
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 #pragma mark -
  27 #pragma mark Event
  28
  29 //------------------------------------------------------------------
  30 // Event functions
  31 //------------------------------------------------------------------
  32
  33 Event::Event(Broadcaster *broadcaster, uint32_t event_type, EventData *data)
  34     : m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
  35       m_data_sp(data) {}
  36
  37 Event::Event(Broadcaster *broadcaster, uint32_t event_type,
  38              const EventDataSP &event_data_sp)
  39     : m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
  40       m_data_sp(event_data_sp) {}
  41
  42 Event::Event(uint32_t event_type, EventData *data)
  43     : m_broadcaster_wp(), m_type(event_type), m_data_sp(data) {}
  44
  45 Event::Event(uint32_t event_type, const EventDataSP &event_data_sp)
  46     : m_broadcaster_wp(), m_type(event_type), m_data_sp(event_data_sp) {}
  47
  48 Event::~Event() = default;
  49
  50 void Event::Dump(Stream *s) const {
  51   Broadcaster *broadcaster;
  52   Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock());
  53   if (broadcaster_impl_sp)
  54     broadcaster = broadcaster_impl_sp->GetBroadcaster();
  55   else
  56     broadcaster = nullptr;
  57
  58   if (broadcaster) {
  59     StreamString event_name;
  60     if (broadcaster->GetEventNames(event_name, m_type, false))
  61       s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
  62                 static_cast<const void *>(this),
  63                 static_cast<void *>(broadcaster),
  64                 broadcaster->GetBroadcasterName().GetCString(), m_type,
  65                 event_name.GetData());
  66     else
  67       s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
  68                 static_cast<const void *>(this),
  69                 static_cast<void *>(broadcaster),
  70                 broadcaster->GetBroadcasterName().GetCString(), m_type);
  71   } else
  72     s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
  73               static_cast<const void *>(this), m_type);
  74
  75   if (m_data_sp) {
  76     s->PutChar('{');
  77     m_data_sp->Dump(s);
  78     s->PutChar('}');
  79   } else
  80     s->Printf("<NULL>");
  81 }
  82
  83 void Event::DoOnRemoval() {
  84   if (m_data_sp)
  85     m_data_sp->DoOnRemoval(this);
  86 }
  87
  88 #pragma mark -
  89 #pragma mark EventData
  90
  91 //------------------------------------------------------------------
  92 // EventData functions
  93 //------------------------------------------------------------------
  94
  95 EventData::EventData() = default;
  96
  97 EventData::~EventData() = default;
  98
  99 void EventData::Dump(Stream *s) const { s->PutCString("Generic Event Data"); }
 100
 101 #pragma mark -
 102 #pragma mark EventDataBytes
 103
 104 //------------------------------------------------------------------
 105 // EventDataBytes functions
 106 //------------------------------------------------------------------
 107
 108 EventDataBytes::EventDataBytes() : m_bytes() {}
 109
 110 EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() {
 111   SetBytesFromCString(cstr);
 112 }
 113
 114 EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() {
 115   SetBytes(str.data(), str.size());
 116 }
 117
 118 EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
 119   SetBytes(src, src_len);
 120 }
 121
 122 EventDataBytes::~EventDataBytes() = default;
 123
 124 const ConstString &EventDataBytes::GetFlavorString() {
 125   static ConstString g_flavor("EventDataBytes");
 126   return g_flavor;
 127 }
 128
 129 const ConstString &EventDataBytes::GetFlavor() const {
 130   return EventDataBytes::GetFlavorString();
 131 }
 132
 133 void EventDataBytes::Dump(Stream *s) const {
 134   size_t num_printable_chars =
 135       std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
 136   if (num_printable_chars == m_bytes.size())
 137     s->Format("\"{0}\"", m_bytes);
 138   else
 139     s->Format("{0:$[ ]@[x-2]}", llvm::make_range(
 140                          reinterpret_cast<const uint8_t *>(m_bytes.data()),
 141                          reinterpret_cast<const uint8_t *>(m_bytes.data() +
 142                                                            m_bytes.size())));
 143 }
 144
 145 const void *EventDataBytes::GetBytes() const {
 146   return (m_bytes.empty() ? nullptr : m_bytes.data());
 147 }
 148
 149 size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); }
 150
 151 void EventDataBytes::SetBytes(const void *src, size_t src_len) {
 152   if (src != nullptr && src_len > 0)
 153     m_bytes.assign((const char *)src, src_len);
 154   else
 155     m_bytes.clear();
 156 }
 157
 158 void EventDataBytes::SetBytesFromCString(const char *cstr) {
 159   if (cstr != nullptr && cstr[0])
 160     m_bytes.assign(cstr);
 161   else
 162     m_bytes.clear();
 163 }
 164
 165 const void *EventDataBytes::GetBytesFromEvent(const Event *event_ptr) {
 166   const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
 167   if (e != nullptr)
 168     return e->GetBytes();
 169   return nullptr;
 170 }
 171
 172 size_t EventDataBytes::GetByteSizeFromEvent(const Event *event_ptr) {
 173   const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
 174   if (e != nullptr)
 175     return e->GetByteSize();
 176   return 0;
 177 }
 178
 179 const EventDataBytes *
 180 EventDataBytes::GetEventDataFromEvent(const Event *event_ptr) {
 181   if (event_ptr != nullptr) {
 182     const EventData *event_data = event_ptr->GetData();
 183     if (event_data &&
 184         event_data->GetFlavor() == EventDataBytes::GetFlavorString())
 185       return static_cast<const EventDataBytes *>(event_data);
 186   }
 187   return nullptr;
 188 }
 189
 190 void EventDataBytes::SwapBytes(std::string &new_bytes) {
 191   m_bytes.swap(new_bytes);
 192 }
 193
 194 #pragma mark -
 195 #pragma mark EventStructuredData
 196
 197 //------------------------------------------------------------------
 198 // EventDataStructuredData definitions
 199 //------------------------------------------------------------------
 200
 201 EventDataStructuredData::EventDataStructuredData()
 202     : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
 203
 204 EventDataStructuredData::EventDataStructuredData(
 205     const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
 206     const lldb::StructuredDataPluginSP &plugin_sp)
 207     : EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
 208       m_plugin_sp(plugin_sp) {}
 209
 210 EventDataStructuredData::~EventDataStructuredData() {}
 211
 212 //------------------------------------------------------------------
 213 // EventDataStructuredData member functions
 214 //------------------------------------------------------------------
 215
 216 const ConstString &EventDataStructuredData::GetFlavor() const {
 217   return EventDataStructuredData::GetFlavorString();
 218 }
 219
 220 void EventDataStructuredData::Dump(Stream *s) const {
 221   if (!s)
 222     return;
 223
 224   if (m_object_sp)
 225     m_object_sp->Dump(*s);
 226 }
 227
 228 const ProcessSP &EventDataStructuredData::GetProcess() const {
 229   return m_process_sp;
 230 }
 231
 232 const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const {
 233   return m_object_sp;
 234 }
 235
 236 const lldb::StructuredDataPluginSP &
 237 EventDataStructuredData::GetStructuredDataPlugin() const {
 238   return m_plugin_sp;
 239 }
 240
 241 void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) {
 242   m_process_sp = process_sp;
 243 }
 244
 245 void EventDataStructuredData::SetObject(
 246     const StructuredData::ObjectSP &object_sp) {
 247   m_object_sp = object_sp;
 248 }
 249
 250 void EventDataStructuredData::SetStructuredDataPlugin(
 251     const lldb::StructuredDataPluginSP &plugin_sp) {
 252   m_plugin_sp = plugin_sp;
 253 }
 254
 255 //------------------------------------------------------------------
 256 // EventDataStructuredData static functions
 257 //------------------------------------------------------------------
 258
 259 const EventDataStructuredData *
 260 EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr) {
 261   if (event_ptr == nullptr)
 262     return nullptr;
 263
 264   const EventData *event_data = event_ptr->GetData();
 265   if (!event_data ||
 266       event_data->GetFlavor() != EventDataStructuredData::GetFlavorString())
 267     return nullptr;
 268
 269   return static_cast<const EventDataStructuredData *>(event_data);
 270 }
 271
 272 ProcessSP EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr) {
 273   auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
 274   if (event_data)
 275     return event_data->GetProcess();
 276   else
 277     return ProcessSP();
 278 }
 279
 280 StructuredData::ObjectSP
 281 EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr) {
 282   auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
 283   if (event_data)
 284     return event_data->GetObject();
 285   else
 286     return StructuredData::ObjectSP();
 287 }
 288
 289 lldb::StructuredDataPluginSP
 290 EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) {
 291   auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
 292   if (event_data)
 293     return event_data->GetStructuredDataPlugin();
 294   else
 295     return StructuredDataPluginSP();
 296 }
 297
 298 const ConstString &EventDataStructuredData::GetFlavorString() {
 299   static ConstString s_flavor("EventDataStructuredData");
 300   return s_flavor;
 301 }