lldb/source/Utility/Event.cpp

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