Event.cpp revision 343218
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/Utility/Event.h" 11 12#include "lldb/Utility/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" 17#include "lldb/lldb-enumerations.h" 18 19#include <algorithm> 20 21#include <ctype.h> 22 23using namespace lldb; 24using namespace lldb_private; 25 26#pragma mark - 27#pragma mark Event 28 29//------------------------------------------------------------------ 30// Event functions 31//------------------------------------------------------------------ 32 33Event::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 37Event::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 42Event::Event(uint32_t event_type, EventData *data) 43 : m_broadcaster_wp(), m_type(event_type), m_data_sp(data) {} 44 45Event::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 48Event::~Event() = default; 49 50void 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 83void 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 95EventData::EventData() = default; 96 97EventData::~EventData() = default; 98 99void 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 108EventDataBytes::EventDataBytes() : m_bytes() {} 109 110EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() { 111 SetBytesFromCString(cstr); 112} 113 114EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() { 115 SetBytes(str.data(), str.size()); 116} 117 118EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() { 119 SetBytes(src, src_len); 120} 121 122EventDataBytes::~EventDataBytes() = default; 123 124const ConstString &EventDataBytes::GetFlavorString() { 125 static ConstString g_flavor("EventDataBytes"); 126 return g_flavor; 127} 128 129const ConstString &EventDataBytes::GetFlavor() const { 130 return EventDataBytes::GetFlavorString(); 131} 132 133void 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 145const void *EventDataBytes::GetBytes() const { 146 return (m_bytes.empty() ? nullptr : m_bytes.data()); 147} 148 149size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); } 150 151void 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 158void EventDataBytes::SetBytesFromCString(const char *cstr) { 159 if (cstr != nullptr && cstr[0]) 160 m_bytes.assign(cstr); 161 else 162 m_bytes.clear(); 163} 164 165const 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 172size_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 179const EventDataBytes * 180EventDataBytes::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 190void 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 201EventDataStructuredData::EventDataStructuredData() 202 : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {} 203 204EventDataStructuredData::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 210EventDataStructuredData::~EventDataStructuredData() {} 211 212//------------------------------------------------------------------ 213// EventDataStructuredData member functions 214//------------------------------------------------------------------ 215 216const ConstString &EventDataStructuredData::GetFlavor() const { 217 return EventDataStructuredData::GetFlavorString(); 218} 219 220void EventDataStructuredData::Dump(Stream *s) const { 221 if (!s) 222 return; 223 224 if (m_object_sp) 225 m_object_sp->Dump(*s); 226} 227 228const ProcessSP &EventDataStructuredData::GetProcess() const { 229 return m_process_sp; 230} 231 232const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const { 233 return m_object_sp; 234} 235 236const lldb::StructuredDataPluginSP & 237EventDataStructuredData::GetStructuredDataPlugin() const { 238 return m_plugin_sp; 239} 240 241void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) { 242 m_process_sp = process_sp; 243} 244 245void EventDataStructuredData::SetObject( 246 const StructuredData::ObjectSP &object_sp) { 247 m_object_sp = object_sp; 248} 249 250void EventDataStructuredData::SetStructuredDataPlugin( 251 const lldb::StructuredDataPluginSP &plugin_sp) { 252 m_plugin_sp = plugin_sp; 253} 254 255//------------------------------------------------------------------ 256// EventDataStructuredData static functions 257//------------------------------------------------------------------ 258 259const EventDataStructuredData * 260EventDataStructuredData::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 272ProcessSP 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 280StructuredData::ObjectSP 281EventDataStructuredData::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 289lldb::StructuredDataPluginSP 290EventDataStructuredData::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 298const ConstString &EventDataStructuredData::GetFlavorString() { 299 static ConstString s_flavor("EventDataStructuredData"); 300 return s_flavor; 301} 302