1 //===-- WatchpointOptions.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/Breakpoint/WatchpointOptions.h" 10 11 #include "lldb/Breakpoint/StoppointCallbackContext.h" 12 #include "lldb/Core/Value.h" 13 #include "lldb/Target/Process.h" 14 #include "lldb/Target/Target.h" 15 #include "lldb/Target/ThreadSpec.h" 16 #include "lldb/Utility/Stream.h" 17 #include "lldb/Utility/StringList.h" 18 19 using namespace lldb; 20 using namespace lldb_private; 21 22 bool WatchpointOptions::NullCallback(void *baton, 23 StoppointCallbackContext *context, 24 lldb::user_id_t watch_id) { 25 return true; 26 } 27 28 // WatchpointOptions constructor 29 WatchpointOptions::WatchpointOptions() 30 : m_callback(WatchpointOptions::NullCallback), m_callback_baton_sp(), 31 m_thread_spec_up() {} 32 33 // WatchpointOptions copy constructor 34 WatchpointOptions::WatchpointOptions(const WatchpointOptions &rhs) 35 : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp), 36 m_callback_is_synchronous(rhs.m_callback_is_synchronous), 37 m_thread_spec_up() { 38 if (rhs.m_thread_spec_up != nullptr) 39 m_thread_spec_up = std::make_unique<ThreadSpec>(*rhs.m_thread_spec_up); 40 } 41 42 // WatchpointOptions assignment operator 43 const WatchpointOptions &WatchpointOptions:: 44 operator=(const WatchpointOptions &rhs) { 45 m_callback = rhs.m_callback; 46 m_callback_baton_sp = rhs.m_callback_baton_sp; 47 m_callback_is_synchronous = rhs.m_callback_is_synchronous; 48 if (rhs.m_thread_spec_up != nullptr) 49 m_thread_spec_up = std::make_unique<ThreadSpec>(*rhs.m_thread_spec_up); 50 return *this; 51 } 52 53 WatchpointOptions * 54 WatchpointOptions::CopyOptionsNoCallback(WatchpointOptions &orig) { 55 WatchpointHitCallback orig_callback = orig.m_callback; 56 lldb::BatonSP orig_callback_baton_sp = orig.m_callback_baton_sp; 57 bool orig_is_sync = orig.m_callback_is_synchronous; 58 59 orig.ClearCallback(); 60 WatchpointOptions *ret_val = new WatchpointOptions(orig); 61 62 orig.SetCallback(orig_callback, orig_callback_baton_sp, orig_is_sync); 63 64 return ret_val; 65 } 66 67 // Destructor 68 WatchpointOptions::~WatchpointOptions() = default; 69 70 // Callbacks 71 void WatchpointOptions::SetCallback(WatchpointHitCallback callback, 72 const BatonSP &callback_baton_sp, 73 bool callback_is_synchronous) { 74 m_callback_is_synchronous = callback_is_synchronous; 75 m_callback = callback; 76 m_callback_baton_sp = callback_baton_sp; 77 } 78 79 void WatchpointOptions::ClearCallback() { 80 m_callback = WatchpointOptions::NullCallback; 81 m_callback_is_synchronous = false; 82 m_callback_baton_sp.reset(); 83 } 84 85 Baton *WatchpointOptions::GetBaton() { return m_callback_baton_sp.get(); } 86 87 const Baton *WatchpointOptions::GetBaton() const { 88 return m_callback_baton_sp.get(); 89 } 90 91 bool WatchpointOptions::InvokeCallback(StoppointCallbackContext *context, 92 lldb::user_id_t watch_id) { 93 if (m_callback && context->is_synchronous == IsCallbackSynchronous()) { 94 return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data() 95 : nullptr, 96 context, watch_id); 97 } else 98 return true; 99 } 100 101 bool WatchpointOptions::HasCallback() { 102 return m_callback != WatchpointOptions::NullCallback; 103 } 104 105 const ThreadSpec *WatchpointOptions::GetThreadSpecNoCreate() const { 106 return m_thread_spec_up.get(); 107 } 108 109 ThreadSpec *WatchpointOptions::GetThreadSpec() { 110 if (m_thread_spec_up == nullptr) 111 m_thread_spec_up = std::make_unique<ThreadSpec>(); 112 113 return m_thread_spec_up.get(); 114 } 115 116 void WatchpointOptions::SetThreadID(lldb::tid_t thread_id) { 117 GetThreadSpec()->SetTID(thread_id); 118 } 119 120 void WatchpointOptions::GetCallbackDescription( 121 Stream *s, lldb::DescriptionLevel level) const { 122 if (m_callback_baton_sp.get()) { 123 s->EOL(); 124 m_callback_baton_sp->GetDescription(s->AsRawOstream(), level, 125 s->GetIndentLevel()); 126 } 127 } 128 129 void WatchpointOptions::GetDescription(Stream *s, 130 lldb::DescriptionLevel level) const { 131 // Figure out if there are any options not at their default value, and only 132 // print anything if there are: 133 134 if ((GetThreadSpecNoCreate() != nullptr && 135 GetThreadSpecNoCreate()->HasSpecification())) { 136 if (level == lldb::eDescriptionLevelVerbose) { 137 s->EOL(); 138 s->IndentMore(); 139 s->Indent(); 140 s->PutCString("Watchpoint Options:\n"); 141 s->IndentMore(); 142 s->Indent(); 143 } else 144 s->PutCString(" Options: "); 145 146 if (m_thread_spec_up) 147 m_thread_spec_up->GetDescription(s, level); 148 else if (level == eDescriptionLevelBrief) 149 s->PutCString("thread spec: no "); 150 if (level == lldb::eDescriptionLevelFull) { 151 s->IndentLess(); 152 s->IndentMore(); 153 } 154 } 155 156 GetCallbackDescription(s, level); 157 } 158 159 void WatchpointOptions::CommandBaton::GetDescription( 160 llvm::raw_ostream &s, lldb::DescriptionLevel level, 161 unsigned indentation) const { 162 const CommandData *data = getItem(); 163 164 if (level == eDescriptionLevelBrief) { 165 s << ", commands = %s" 166 << ((data && data->user_source.GetSize() > 0) ? "yes" : "no"); 167 return; 168 } 169 170 indentation += 2; 171 s.indent(indentation); 172 s << "watchpoint commands:\n"; 173 174 indentation += 2; 175 if (data && data->user_source.GetSize() > 0) { 176 for (const std::string &line : data->user_source) { 177 s.indent(indentation); 178 s << line << "\n"; 179 } 180 } else 181 s << "No commands.\n"; 182 } 183