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