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/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() { LLDB_INSTRUMENT_VA(this); } 26 27 SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len) 28 : m_event_sp(new Event(event_type, new EventDataBytes(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 lldb_event->GetData()->GetFlavor().AsCString(); 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 lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString(); 99 else 100 return "unknown class"; 101 } 102 103 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) { 104 LLDB_INSTRUMENT_VA(this, broadcaster); 105 106 if (broadcaster) 107 return BroadcasterMatchesRef(*broadcaster); 108 return false; 109 } 110 111 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) { 112 LLDB_INSTRUMENT_VA(this, broadcaster); 113 114 Event *lldb_event = get(); 115 bool success = false; 116 if (lldb_event) 117 success = lldb_event->BroadcasterIs(broadcaster.get()); 118 119 120 return success; 121 } 122 123 void SBEvent::Clear() { 124 LLDB_INSTRUMENT_VA(this); 125 126 Event *lldb_event = get(); 127 if (lldb_event) 128 lldb_event->Clear(); 129 } 130 131 EventSP &SBEvent::GetSP() const { return m_event_sp; } 132 133 Event *SBEvent::get() const { 134 // There is a dangerous accessor call GetSharedPtr which can be used, so if 135 // we have anything valid in m_event_sp, we must use that since if it gets 136 // used by a function that puts something in there, then it won't update 137 // m_opaque_ptr... 138 if (m_event_sp) 139 m_opaque_ptr = m_event_sp.get(); 140 141 return m_opaque_ptr; 142 } 143 144 void SBEvent::reset(EventSP &event_sp) { 145 m_event_sp = event_sp; 146 m_opaque_ptr = m_event_sp.get(); 147 } 148 149 void SBEvent::reset(Event *event_ptr) { 150 m_opaque_ptr = event_ptr; 151 m_event_sp.reset(); 152 } 153 154 bool SBEvent::IsValid() const { 155 LLDB_INSTRUMENT_VA(this); 156 return this->operator bool(); 157 } 158 SBEvent::operator bool() const { 159 LLDB_INSTRUMENT_VA(this); 160 161 // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor. 162 // See comments in SBEvent::get().... 163 return SBEvent::get() != nullptr; 164 } 165 166 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) { 167 LLDB_INSTRUMENT_VA(event); 168 169 return static_cast<const char *>( 170 EventDataBytes::GetBytesFromEvent(event.get())); 171 } 172 173 bool SBEvent::GetDescription(SBStream &description) { 174 LLDB_INSTRUMENT_VA(this, description); 175 176 Stream &strm = description.ref(); 177 178 if (get()) { 179 m_opaque_ptr->Dump(&strm); 180 } else 181 strm.PutCString("No value"); 182 183 return true; 184 } 185 186 bool SBEvent::GetDescription(SBStream &description) const { 187 LLDB_INSTRUMENT_VA(this, description); 188 189 Stream &strm = description.ref(); 190 191 if (get()) { 192 m_opaque_ptr->Dump(&strm); 193 } else 194 strm.PutCString("No value"); 195 196 return true; 197 } 198