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