1 //===-- Event.cpp -----------------------------------------------*- C++ -*-===//
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 //------------------------------------------------------------------
29 // Event functions
30 //------------------------------------------------------------------
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().GetCString(), 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().GetCString(), 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 //------------------------------------------------------------------
91 // EventData functions
92 //------------------------------------------------------------------
93 
94 EventData::EventData() = default;
95 
96 EventData::~EventData() = default;
97 
98 void EventData::Dump(Stream *s) const { s->PutCString("Generic Event Data"); }
99 
100 #pragma mark -
101 #pragma mark EventDataBytes
102 
103 //------------------------------------------------------------------
104 // EventDataBytes functions
105 //------------------------------------------------------------------
106 
107 EventDataBytes::EventDataBytes() : m_bytes() {}
108 
109 EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() {
110   SetBytesFromCString(cstr);
111 }
112 
113 EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() {
114   SetBytes(str.data(), str.size());
115 }
116 
117 EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
118   SetBytes(src, src_len);
119 }
120 
121 EventDataBytes::~EventDataBytes() = default;
122 
123 ConstString EventDataBytes::GetFlavorString() {
124   static ConstString g_flavor("EventDataBytes");
125   return g_flavor;
126 }
127 
128 ConstString EventDataBytes::GetFlavor() const {
129   return EventDataBytes::GetFlavorString();
130 }
131 
132 void EventDataBytes::Dump(Stream *s) const {
133   size_t num_printable_chars =
134       std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
135   if (num_printable_chars == m_bytes.size())
136     s->Format("\"{0}\"", m_bytes);
137   else
138     s->Format("{0:$[ ]@[x-2]}", llvm::make_range(
139                          reinterpret_cast<const uint8_t *>(m_bytes.data()),
140                          reinterpret_cast<const uint8_t *>(m_bytes.data() +
141                                                            m_bytes.size())));
142 }
143 
144 const void *EventDataBytes::GetBytes() const {
145   return (m_bytes.empty() ? nullptr : m_bytes.data());
146 }
147 
148 size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); }
149 
150 void EventDataBytes::SetBytes(const void *src, size_t src_len) {
151   if (src != nullptr && src_len > 0)
152     m_bytes.assign((const char *)src, src_len);
153   else
154     m_bytes.clear();
155 }
156 
157 void EventDataBytes::SetBytesFromCString(const char *cstr) {
158   if (cstr != nullptr && cstr[0])
159     m_bytes.assign(cstr);
160   else
161     m_bytes.clear();
162 }
163 
164 const void *EventDataBytes::GetBytesFromEvent(const Event *event_ptr) {
165   const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
166   if (e != nullptr)
167     return e->GetBytes();
168   return nullptr;
169 }
170 
171 size_t EventDataBytes::GetByteSizeFromEvent(const Event *event_ptr) {
172   const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
173   if (e != nullptr)
174     return e->GetByteSize();
175   return 0;
176 }
177 
178 const EventDataBytes *
179 EventDataBytes::GetEventDataFromEvent(const Event *event_ptr) {
180   if (event_ptr != nullptr) {
181     const EventData *event_data = event_ptr->GetData();
182     if (event_data &&
183         event_data->GetFlavor() == EventDataBytes::GetFlavorString())
184       return static_cast<const EventDataBytes *>(event_data);
185   }
186   return nullptr;
187 }
188 
189 void EventDataBytes::SwapBytes(std::string &new_bytes) {
190   m_bytes.swap(new_bytes);
191 }
192 
193 #pragma mark -
194 #pragma mark EventStructuredData
195 
196 //------------------------------------------------------------------
197 // EventDataStructuredData definitions
198 //------------------------------------------------------------------
199 
200 EventDataStructuredData::EventDataStructuredData()
201     : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
202 
203 EventDataStructuredData::EventDataStructuredData(
204     const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
205     const lldb::StructuredDataPluginSP &plugin_sp)
206     : EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
207       m_plugin_sp(plugin_sp) {}
208 
209 EventDataStructuredData::~EventDataStructuredData() {}
210 
211 //------------------------------------------------------------------
212 // EventDataStructuredData member functions
213 //------------------------------------------------------------------
214 
215 ConstString EventDataStructuredData::GetFlavor() const {
216   return EventDataStructuredData::GetFlavorString();
217 }
218 
219 void EventDataStructuredData::Dump(Stream *s) const {
220   if (!s)
221     return;
222 
223   if (m_object_sp)
224     m_object_sp->Dump(*s);
225 }
226 
227 const ProcessSP &EventDataStructuredData::GetProcess() const {
228   return m_process_sp;
229 }
230 
231 const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const {
232   return m_object_sp;
233 }
234 
235 const lldb::StructuredDataPluginSP &
236 EventDataStructuredData::GetStructuredDataPlugin() const {
237   return m_plugin_sp;
238 }
239 
240 void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) {
241   m_process_sp = process_sp;
242 }
243 
244 void EventDataStructuredData::SetObject(
245     const StructuredData::ObjectSP &object_sp) {
246   m_object_sp = object_sp;
247 }
248 
249 void EventDataStructuredData::SetStructuredDataPlugin(
250     const lldb::StructuredDataPluginSP &plugin_sp) {
251   m_plugin_sp = plugin_sp;
252 }
253 
254 //------------------------------------------------------------------
255 // EventDataStructuredData static functions
256 //------------------------------------------------------------------
257 
258 const EventDataStructuredData *
259 EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr) {
260   if (event_ptr == nullptr)
261     return nullptr;
262 
263   const EventData *event_data = event_ptr->GetData();
264   if (!event_data ||
265       event_data->GetFlavor() != EventDataStructuredData::GetFlavorString())
266     return nullptr;
267 
268   return static_cast<const EventDataStructuredData *>(event_data);
269 }
270 
271 ProcessSP EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr) {
272   auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
273   if (event_data)
274     return event_data->GetProcess();
275   else
276     return ProcessSP();
277 }
278 
279 StructuredData::ObjectSP
280 EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr) {
281   auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
282   if (event_data)
283     return event_data->GetObject();
284   else
285     return StructuredData::ObjectSP();
286 }
287 
288 lldb::StructuredDataPluginSP
289 EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) {
290   auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
291   if (event_data)
292     return event_data->GetStructuredDataPlugin();
293   else
294     return StructuredDataPluginSP();
295 }
296 
297 ConstString EventDataStructuredData::GetFlavorString() {
298   static ConstString s_flavor("EventDataStructuredData");
299   return s_flavor;
300 }
301