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 <ctype.h> 21 22using namespace lldb; 23using namespace lldb_private; 24 25#pragma mark - 26#pragma mark Event 27 28// Event functions 29 30Event::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 34Event::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 39Event::Event(uint32_t event_type, EventData *data) 40 : m_broadcaster_wp(), m_type(event_type), m_data_sp(data) {} 41 42Event::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 45Event::~Event() = default; 46 47void 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 80void 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 90EventData::EventData() = default; 91 92EventData::~EventData() = default; 93 94void EventData::Dump(Stream *s) const { s->PutCString("Generic Event Data"); } 95 96#pragma mark - 97#pragma mark EventDataBytes 98 99// EventDataBytes functions 100 101EventDataBytes::EventDataBytes() : m_bytes() {} 102 103EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() { 104 SetBytesFromCString(cstr); 105} 106 107EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() { 108 SetBytes(str.data(), str.size()); 109} 110 111EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() { 112 SetBytes(src, src_len); 113} 114 115EventDataBytes::~EventDataBytes() = default; 116 117ConstString EventDataBytes::GetFlavorString() { 118 static ConstString g_flavor("EventDataBytes"); 119 return g_flavor; 120} 121 122ConstString EventDataBytes::GetFlavor() const { 123 return EventDataBytes::GetFlavorString(); 124} 125 126void 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 138const void *EventDataBytes::GetBytes() const { 139 return (m_bytes.empty() ? nullptr : m_bytes.data()); 140} 141 142size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); } 143 144void 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 151void EventDataBytes::SetBytesFromCString(const char *cstr) { 152 if (cstr != nullptr && cstr[0]) 153 m_bytes.assign(cstr); 154 else 155 m_bytes.clear(); 156} 157 158const 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 165size_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 172const EventDataBytes * 173EventDataBytes::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 183void 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 192EventDataStructuredData::EventDataStructuredData() 193 : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {} 194 195EventDataStructuredData::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 201EventDataStructuredData::~EventDataStructuredData() {} 202 203// EventDataStructuredData member functions 204 205ConstString EventDataStructuredData::GetFlavor() const { 206 return EventDataStructuredData::GetFlavorString(); 207} 208 209void EventDataStructuredData::Dump(Stream *s) const { 210 if (!s) 211 return; 212 213 if (m_object_sp) 214 m_object_sp->Dump(*s); 215} 216 217const ProcessSP &EventDataStructuredData::GetProcess() const { 218 return m_process_sp; 219} 220 221const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const { 222 return m_object_sp; 223} 224 225const lldb::StructuredDataPluginSP & 226EventDataStructuredData::GetStructuredDataPlugin() const { 227 return m_plugin_sp; 228} 229 230void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) { 231 m_process_sp = process_sp; 232} 233 234void EventDataStructuredData::SetObject( 235 const StructuredData::ObjectSP &object_sp) { 236 m_object_sp = object_sp; 237} 238 239void EventDataStructuredData::SetStructuredDataPlugin( 240 const lldb::StructuredDataPluginSP &plugin_sp) { 241 m_plugin_sp = plugin_sp; 242} 243 244// EventDataStructuredData static functions 245 246const EventDataStructuredData * 247EventDataStructuredData::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 259ProcessSP 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 267StructuredData::ObjectSP 268EventDataStructuredData::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 276lldb::StructuredDataPluginSP 277EventDataStructuredData::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 285ConstString EventDataStructuredData::GetFlavorString() { 286 static ConstString s_flavor("EventDataStructuredData"); 287 return s_flavor; 288} 289