1 //===-- Watchpoint.cpp ------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 // Other libraries and framework includes
14 #include "lldb/Breakpoint/Watchpoint.h"
16 #include "lldb/Breakpoint/StoppointCallbackContext.h"
17 #include "lldb/Core/Stream.h"
18 #include "lldb/Core/Value.h"
19 #include "lldb/Core/ValueObject.h"
20 #include "lldb/Core/ValueObjectMemory.h"
21 #include "lldb/Expression/UserExpression.h"
22 #include "lldb/Symbol/ClangASTContext.h"
23 #include "lldb/Target/Process.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Target/ThreadSpec.h"
28 using namespace lldb_private;
30 Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
31 const CompilerType *type, bool hardware)
32 : StoppointLocation(0, addr, size, hardware), m_target(target),
33 m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
34 m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0),
35 m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0),
36 m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(),
37 m_type(), m_error(), m_options(), m_being_created(true) {
38 if (type && type->IsValid())
41 // If we don't have a known type, then we force it to unsigned int of the
43 ClangASTContext *ast_context = target.GetScratchClangASTContext();
44 m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint,
48 // Set the initial value of the watched variable:
49 if (m_target.GetProcessSP()) {
50 ExecutionContext exe_ctx;
51 m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
52 CaptureWatchedValue(exe_ctx);
54 m_being_created = false;
57 Watchpoint::~Watchpoint() = default;
59 // This function is used when "baton" doesn't need to be freed
60 void Watchpoint::SetCallback(WatchpointHitCallback callback, void *baton,
61 bool is_synchronous) {
62 // The default "Baton" class will keep a copy of "baton" and won't free
63 // or delete it when it goes goes out of scope.
64 m_options.SetCallback(callback, std::make_shared<UntypedBaton>(baton),
67 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
70 // This function is used when a baton needs to be freed and therefore is
71 // contained in a "Baton" subclass.
72 void Watchpoint::SetCallback(WatchpointHitCallback callback,
73 const BatonSP &callback_baton_sp,
74 bool is_synchronous) {
75 m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
76 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
79 void Watchpoint::ClearCallback() {
80 m_options.ClearCallback();
81 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
84 void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; }
86 std::string Watchpoint::GetWatchSpec() { return m_watch_spec_str; }
88 void Watchpoint::SetWatchSpec(const std::string &str) {
89 m_watch_spec_str = str;
92 // Override default impl of StoppointLocation::IsHardware() since m_is_hardware
93 // member field is more accurate.
94 bool Watchpoint::IsHardware() const { return m_is_hardware; }
96 bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; }
98 void Watchpoint::SetWatchVariable(bool val) { m_is_watch_variable = val; }
100 bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) {
101 ConstString watch_name("$__lldb__watch_value");
102 m_old_value_sp = m_new_value_sp;
103 Address watch_address(GetLoadAddress());
104 if (!m_type.IsValid()) {
105 // Don't know how to report new & old values, since we couldn't make a
106 // scalar type for this watchpoint.
107 // This works around an assert in ValueObjectMemory::Create.
108 // FIXME: This should not happen, but if it does in some case we care about,
109 // we can go grab the value raw and print it as unsigned.
112 m_new_value_sp = ValueObjectMemory::Create(
113 exe_ctx.GetBestExecutionContextScope(), watch_name.GetStringRef(),
114 watch_address, m_type);
115 m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name);
116 return (m_new_value_sp && m_new_value_sp->GetError().Success());
119 void Watchpoint::IncrementFalseAlarmsAndReviseHitCount() {
121 if (m_false_alarms) {
122 if (m_hit_count >= m_false_alarms) {
123 m_hit_count -= m_false_alarms;
126 m_false_alarms -= m_hit_count;
132 // RETURNS - true if we should stop at this breakpoint, false if we
135 bool Watchpoint::ShouldStop(StoppointCallbackContext *context) {
144 void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) {
145 DumpWithLevel(s, level);
148 void Watchpoint::Dump(Stream *s) const {
149 DumpWithLevel(s, lldb::eDescriptionLevelBrief);
152 // If prefix is nullptr, we display the watch id and ignore the prefix
154 void Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const {
156 s->Printf("\nWatchpoint %u hit:", GetID());
160 if (m_old_value_sp) {
161 const char *old_value_cstr = m_old_value_sp->GetValueAsCString();
162 if (old_value_cstr && old_value_cstr[0])
163 s->Printf("\n%sold value: %s", prefix, old_value_cstr);
165 const char *old_summary_cstr = m_old_value_sp->GetSummaryAsCString();
166 if (old_summary_cstr && old_summary_cstr[0])
167 s->Printf("\n%sold value: %s", prefix, old_summary_cstr);
171 if (m_new_value_sp) {
172 const char *new_value_cstr = m_new_value_sp->GetValueAsCString();
173 if (new_value_cstr && new_value_cstr[0])
174 s->Printf("\n%snew value: %s", prefix, new_value_cstr);
176 const char *new_summary_cstr = m_new_value_sp->GetSummaryAsCString();
177 if (new_summary_cstr && new_summary_cstr[0])
178 s->Printf("\n%snew value: %s", prefix, new_summary_cstr);
183 void Watchpoint::DumpWithLevel(Stream *s,
184 lldb::DescriptionLevel description_level) const {
188 assert(description_level >= lldb::eDescriptionLevelBrief &&
189 description_level <= lldb::eDescriptionLevelVerbose);
191 s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64
192 " size = %u state = %s type = %s%s",
193 GetID(), GetLoadAddress(), m_byte_size,
194 IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "",
195 m_watch_write ? "w" : "");
197 if (description_level >= lldb::eDescriptionLevelFull) {
198 if (!m_decl_str.empty())
199 s->Printf("\n declare @ '%s'", m_decl_str.c_str());
200 if (!m_watch_spec_str.empty())
201 s->Printf("\n watchpoint spec = '%s'", m_watch_spec_str.c_str());
203 // Dump the snapshots we have taken.
204 DumpSnapshots(s, " ");
206 if (GetConditionText())
207 s->Printf("\n condition = '%s'", GetConditionText());
208 m_options.GetCallbackDescription(s, description_level);
211 if (description_level >= lldb::eDescriptionLevelVerbose) {
212 s->Printf("\n hw_index = %i hit_count = %-4u ignore_count = %-4u",
213 GetHardwareIndex(), GetHitCount(), GetIgnoreCount());
217 bool Watchpoint::IsEnabled() const { return m_enabled; }
219 // Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
220 // temporarily disable the watchpoint
221 // in order to perform possible watchpoint actions without triggering further
222 // watchpoint events.
223 // After the temporary disabled watchpoint is enabled, we then turn off the
226 void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; }
228 void Watchpoint::TurnOffEphemeralMode() {
229 m_is_ephemeral = false;
230 // Leaving ephemeral mode, reset the m_disabled_count!
231 m_disabled_count = 0;
234 bool Watchpoint::IsDisabledDuringEphemeralMode() {
235 return m_disabled_count > 1 && m_is_ephemeral;
238 void Watchpoint::SetEnabled(bool enabled, bool notify) {
241 SetHardwareIndex(LLDB_INVALID_INDEX32);
245 // Don't clear the snapshots for now.
246 // Within StopInfo.cpp, we purposely do disable/enable watchpoint while
247 // performing watchpoint actions.
249 bool changed = enabled != m_enabled;
251 if (notify && !m_is_ephemeral && changed)
252 SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled
253 : eWatchpointEventTypeDisabled);
256 void Watchpoint::SetWatchpointType(uint32_t type, bool notify) {
257 int old_watch_read = m_watch_read;
258 int old_watch_write = m_watch_write;
259 m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
260 m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
262 (old_watch_read != m_watch_read || old_watch_write != m_watch_write))
263 SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged);
266 bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; }
268 bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; }
270 uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; }
272 void Watchpoint::SetIgnoreCount(uint32_t n) {
273 bool changed = m_ignore_count != n;
276 SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged);
279 bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) {
280 return m_options.InvokeCallback(context, GetID());
283 void Watchpoint::SetCondition(const char *condition) {
284 if (condition == nullptr || condition[0] == '\0') {
285 if (m_condition_ap.get())
286 m_condition_ap.reset();
288 // Pass nullptr for expr_prefix (no translation-unit level definitions).
290 m_condition_ap.reset(m_target.GetUserExpressionForLanguage(
291 condition, llvm::StringRef(), lldb::eLanguageTypeUnknown,
292 UserExpression::eResultTypeAny, EvaluateExpressionOptions(), error));
294 // FIXME: Log something...
295 m_condition_ap.reset();
298 SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged);
301 const char *Watchpoint::GetConditionText() const {
302 if (m_condition_ap.get())
303 return m_condition_ap->GetUserText();
308 void Watchpoint::SendWatchpointChangedEvent(
309 lldb::WatchpointEventType eventKind) {
310 if (!m_being_created &&
311 GetTarget().EventTypeHasListeners(
312 Target::eBroadcastBitWatchpointChanged)) {
313 WatchpointEventData *data =
314 new Watchpoint::WatchpointEventData(eventKind, shared_from_this());
315 GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
319 void Watchpoint::SendWatchpointChangedEvent(WatchpointEventData *data) {
323 if (!m_being_created &&
324 GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
325 GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
330 Watchpoint::WatchpointEventData::WatchpointEventData(
331 WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
332 : EventData(), m_watchpoint_event(sub_type),
333 m_new_watchpoint_sp(new_watchpoint_sp) {}
335 Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
337 const ConstString &Watchpoint::WatchpointEventData::GetFlavorString() {
338 static ConstString g_flavor("Watchpoint::WatchpointEventData");
342 const ConstString &Watchpoint::WatchpointEventData::GetFlavor() const {
343 return WatchpointEventData::GetFlavorString();
346 WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() {
347 return m_new_watchpoint_sp;
351 Watchpoint::WatchpointEventData::GetWatchpointEventType() const {
352 return m_watchpoint_event;
355 void Watchpoint::WatchpointEventData::Dump(Stream *s) const {}
357 const Watchpoint::WatchpointEventData *
358 Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) {
360 const EventData *event_data = event->GetData();
362 event_data->GetFlavor() == WatchpointEventData::GetFlavorString())
363 return static_cast<const WatchpointEventData *>(event->GetData());
369 Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
370 const EventSP &event_sp) {
371 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
374 return eWatchpointEventTypeInvalidType;
376 return data->GetWatchpointEventType();
379 WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
380 const EventSP &event_sp) {
383 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
385 wp_sp = data->m_new_watchpoint_sp;