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