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