1 //===-- SBEvent.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/API/SBEvent.h" 10 #include "SBReproducerPrivate.h" 11 #include "lldb/API/SBBroadcaster.h" 12 #include "lldb/API/SBStream.h" 13 14 #include "lldb/Breakpoint/Breakpoint.h" 15 #include "lldb/Core/StreamFile.h" 16 #include "lldb/Interpreter/CommandInterpreter.h" 17 #include "lldb/Target/Process.h" 18 #include "lldb/Utility/ConstString.h" 19 #include "lldb/Utility/Event.h" 20 #include "lldb/Utility/Stream.h" 21 22 using namespace lldb; 23 using namespace lldb_private; 24 25 SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(nullptr) { 26 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent); 27 } 28 29 SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len) 30 : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))), 31 m_opaque_ptr(m_event_sp.get()) { 32 LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t), 33 event_type, cstr, cstr_len); 34 } 35 36 SBEvent::SBEvent(EventSP &event_sp) 37 : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) { 38 LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp); 39 } 40 41 SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) { 42 LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr); 43 } 44 45 SBEvent::SBEvent(const SBEvent &rhs) 46 : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) { 47 LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs); 48 } 49 50 const SBEvent &SBEvent::operator=(const SBEvent &rhs) { 51 LLDB_RECORD_METHOD(const lldb::SBEvent &, 52 SBEvent, operator=,(const lldb::SBEvent &), rhs); 53 54 if (this != &rhs) { 55 m_event_sp = rhs.m_event_sp; 56 m_opaque_ptr = rhs.m_opaque_ptr; 57 } 58 return LLDB_RECORD_RESULT(*this); 59 } 60 61 SBEvent::~SBEvent() = default; 62 63 const char *SBEvent::GetDataFlavor() { 64 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor); 65 66 Event *lldb_event = get(); 67 if (lldb_event) { 68 EventData *event_data = lldb_event->GetData(); 69 if (event_data) 70 return lldb_event->GetData()->GetFlavor().AsCString(); 71 } 72 return nullptr; 73 } 74 75 uint32_t SBEvent::GetType() const { 76 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType); 77 78 79 const Event *lldb_event = get(); 80 uint32_t event_type = 0; 81 if (lldb_event) 82 event_type = lldb_event->GetType(); 83 84 85 return event_type; 86 } 87 88 SBBroadcaster SBEvent::GetBroadcaster() const { 89 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent, 90 GetBroadcaster); 91 92 SBBroadcaster broadcaster; 93 const Event *lldb_event = get(); 94 if (lldb_event) 95 broadcaster.reset(lldb_event->GetBroadcaster(), false); 96 return LLDB_RECORD_RESULT(broadcaster); 97 } 98 99 const char *SBEvent::GetBroadcasterClass() const { 100 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass); 101 102 const Event *lldb_event = get(); 103 if (lldb_event) 104 return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString(); 105 else 106 return "unknown class"; 107 } 108 109 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) { 110 LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr, 111 (const lldb::SBBroadcaster *), broadcaster); 112 113 if (broadcaster) 114 return BroadcasterMatchesRef(*broadcaster); 115 return false; 116 } 117 118 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) { 119 LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef, 120 (const lldb::SBBroadcaster &), broadcaster); 121 122 Event *lldb_event = get(); 123 bool success = false; 124 if (lldb_event) 125 success = lldb_event->BroadcasterIs(broadcaster.get()); 126 127 128 return success; 129 } 130 131 void SBEvent::Clear() { 132 LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear); 133 134 Event *lldb_event = get(); 135 if (lldb_event) 136 lldb_event->Clear(); 137 } 138 139 EventSP &SBEvent::GetSP() const { return m_event_sp; } 140 141 Event *SBEvent::get() const { 142 // There is a dangerous accessor call GetSharedPtr which can be used, so if 143 // we have anything valid in m_event_sp, we must use that since if it gets 144 // used by a function that puts something in there, then it won't update 145 // m_opaque_ptr... 146 if (m_event_sp) 147 m_opaque_ptr = m_event_sp.get(); 148 149 return m_opaque_ptr; 150 } 151 152 void SBEvent::reset(EventSP &event_sp) { 153 m_event_sp = event_sp; 154 m_opaque_ptr = m_event_sp.get(); 155 } 156 157 void SBEvent::reset(Event *event_ptr) { 158 m_opaque_ptr = event_ptr; 159 m_event_sp.reset(); 160 } 161 162 bool SBEvent::IsValid() const { 163 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid); 164 return this->operator bool(); 165 } 166 SBEvent::operator bool() const { 167 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool); 168 169 // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor. 170 // See comments in SBEvent::get().... 171 return SBEvent::get() != nullptr; 172 } 173 174 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) { 175 LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, 176 (const lldb::SBEvent &), event); 177 178 return static_cast<const char *>( 179 EventDataBytes::GetBytesFromEvent(event.get())); 180 } 181 182 bool SBEvent::GetDescription(SBStream &description) { 183 LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &), 184 description); 185 186 Stream &strm = description.ref(); 187 188 if (get()) { 189 m_opaque_ptr->Dump(&strm); 190 } else 191 strm.PutCString("No value"); 192 193 return true; 194 } 195 196 bool SBEvent::GetDescription(SBStream &description) const { 197 LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &), 198 description); 199 200 Stream &strm = description.ref(); 201 202 if (get()) { 203 m_opaque_ptr->Dump(&strm); 204 } else 205 strm.PutCString("No value"); 206 207 return true; 208 } 209 210 namespace lldb_private { 211 namespace repro { 212 213 template <> 214 void RegisterMethods<SBEvent>(Registry &R) { 215 LLDB_REGISTER_CONSTRUCTOR(SBEvent, ()); 216 LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t)); 217 LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &)); 218 LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *)); 219 LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &)); 220 LLDB_REGISTER_METHOD(const lldb::SBEvent &, 221 SBEvent, operator=,(const lldb::SBEvent &)); 222 LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ()); 223 LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ()); 224 LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster, 225 ()); 226 LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ()); 227 LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr, 228 (const lldb::SBBroadcaster *)); 229 LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef, 230 (const lldb::SBBroadcaster &)); 231 LLDB_REGISTER_METHOD(void, SBEvent, Clear, ()); 232 LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ()); 233 LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ()); 234 LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent, 235 (const lldb::SBEvent &)); 236 LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &)); 237 LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription, 238 (lldb::SBStream &)); 239 } 240 241 } 242 } 243