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 
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() {}
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 }
289