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
22using namespace lldb;
23using namespace lldb_private;
24
25#pragma mark -
26#pragma mark Event
27
28// Event functions
29
30Event::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
34Event::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
39Event::Event(uint32_t event_type, EventData *data)
40    : m_broadcaster_wp(), m_type(event_type), m_data_sp(data) {}
41
42Event::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
45Event::~Event() = default;
46
47void 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
80void 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
90EventData::EventData() = default;
91
92EventData::~EventData() = default;
93
94void EventData::Dump(Stream *s) const { s->PutCString("Generic Event Data"); }
95
96#pragma mark -
97#pragma mark EventDataBytes
98
99// EventDataBytes functions
100
101EventDataBytes::EventDataBytes() : m_bytes() {}
102
103EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() {
104  SetBytesFromCString(cstr);
105}
106
107EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() {
108  SetBytes(str.data(), str.size());
109}
110
111EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
112  SetBytes(src, src_len);
113}
114
115EventDataBytes::~EventDataBytes() = default;
116
117ConstString EventDataBytes::GetFlavorString() {
118  static ConstString g_flavor("EventDataBytes");
119  return g_flavor;
120}
121
122ConstString EventDataBytes::GetFlavor() const {
123  return EventDataBytes::GetFlavorString();
124}
125
126void 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
138const void *EventDataBytes::GetBytes() const {
139  return (m_bytes.empty() ? nullptr : m_bytes.data());
140}
141
142size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); }
143
144void 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
151void EventDataBytes::SetBytesFromCString(const char *cstr) {
152  if (cstr != nullptr && cstr[0])
153    m_bytes.assign(cstr);
154  else
155    m_bytes.clear();
156}
157
158const 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
165size_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
172const EventDataBytes *
173EventDataBytes::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
183void 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
192EventDataStructuredData::EventDataStructuredData()
193    : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
194
195EventDataStructuredData::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
201EventDataStructuredData::~EventDataStructuredData() {}
202
203// EventDataStructuredData member functions
204
205ConstString EventDataStructuredData::GetFlavor() const {
206  return EventDataStructuredData::GetFlavorString();
207}
208
209void EventDataStructuredData::Dump(Stream *s) const {
210  if (!s)
211    return;
212
213  if (m_object_sp)
214    m_object_sp->Dump(*s);
215}
216
217const ProcessSP &EventDataStructuredData::GetProcess() const {
218  return m_process_sp;
219}
220
221const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const {
222  return m_object_sp;
223}
224
225const lldb::StructuredDataPluginSP &
226EventDataStructuredData::GetStructuredDataPlugin() const {
227  return m_plugin_sp;
228}
229
230void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) {
231  m_process_sp = process_sp;
232}
233
234void EventDataStructuredData::SetObject(
235    const StructuredData::ObjectSP &object_sp) {
236  m_object_sp = object_sp;
237}
238
239void EventDataStructuredData::SetStructuredDataPlugin(
240    const lldb::StructuredDataPluginSP &plugin_sp) {
241  m_plugin_sp = plugin_sp;
242}
243
244// EventDataStructuredData static functions
245
246const EventDataStructuredData *
247EventDataStructuredData::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
259ProcessSP 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
267StructuredData::ObjectSP
268EventDataStructuredData::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
276lldb::StructuredDataPluginSP
277EventDataStructuredData::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
285ConstString EventDataStructuredData::GetFlavorString() {
286  static ConstString s_flavor("EventDataStructuredData");
287  return s_flavor;
288}
289