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