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 //===----------------------------------------------------------------------===//
10 #include "lldb/Breakpoint/Watchpoint.h"
12 #include "lldb/Breakpoint/StoppointCallbackContext.h"
13 #include "lldb/Core/Value.h"
14 #include "lldb/Core/ValueObject.h"
15 #include "lldb/Core/ValueObjectMemory.h"
16 #include "lldb/Expression/UserExpression.h"
17 #include "lldb/Symbol/ClangASTContext.h"
18 #include "lldb/Target/Process.h"
19 #include "lldb/Target/Target.h"
20 #include "lldb/Target/ThreadSpec.h"
21 #include "lldb/Utility/Stream.h"
24 using namespace lldb_private;
26 Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
27 const CompilerType *type, bool hardware)
28 : StoppointLocation(0, addr, size, hardware), m_target(target),
29 m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
30 m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0),
31 m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0),
32 m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(),
33 m_type(), m_error(), m_options(), m_being_created(true) {
34 if (type && type->IsValid())
37 // If we don't have a known type, then we force it to unsigned int of the
39 ClangASTContext *ast_context = target.GetScratchClangASTContext();
40 m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint,
44 // Set the initial value of the watched variable:
45 if (m_target.GetProcessSP()) {
46 ExecutionContext exe_ctx;
47 m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
48 CaptureWatchedValue(exe_ctx);
50 m_being_created = false;
53 Watchpoint::~Watchpoint() = default;
55 // This function is used when "baton" doesn't need to be freed
56 void Watchpoint::SetCallback(WatchpointHitCallback callback, void *baton,
57 bool is_synchronous) {
58 // The default "Baton" class will keep a copy of "baton" and won't free or
59 // delete it when it goes goes out of scope.
60 m_options.SetCallback(callback, std::make_shared<UntypedBaton>(baton),
63 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
66 // This function is used when a baton needs to be freed and therefore is
67 // contained in a "Baton" subclass.
68 void Watchpoint::SetCallback(WatchpointHitCallback callback,
69 const BatonSP &callback_baton_sp,
70 bool is_synchronous) {
71 m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
72 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
75 void Watchpoint::ClearCallback() {
76 m_options.ClearCallback();
77 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
80 void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; }
82 std::string Watchpoint::GetWatchSpec() { return m_watch_spec_str; }
84 void Watchpoint::SetWatchSpec(const std::string &str) {
85 m_watch_spec_str = str;
88 // Override default impl of StoppointLocation::IsHardware() since m_is_hardware
89 // member field is more accurate.
90 bool Watchpoint::IsHardware() const { return m_is_hardware; }
92 bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; }
94 void Watchpoint::SetWatchVariable(bool val) { m_is_watch_variable = val; }
96 bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) {
97 ConstString watch_name("$__lldb__watch_value");
98 m_old_value_sp = m_new_value_sp;
99 Address watch_address(GetLoadAddress());
100 if (!m_type.IsValid()) {
101 // Don't know how to report new & old values, since we couldn't make a
102 // scalar type for this watchpoint. This works around an assert in
103 // ValueObjectMemory::Create.
104 // FIXME: This should not happen, but if it does in some case we care about,
105 // we can go grab the value raw and print it as unsigned.
108 m_new_value_sp = ValueObjectMemory::Create(
109 exe_ctx.GetBestExecutionContextScope(), watch_name.GetStringRef(),
110 watch_address, m_type);
111 m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name);
112 return (m_new_value_sp && m_new_value_sp->GetError().Success());
115 void Watchpoint::IncrementFalseAlarmsAndReviseHitCount() {
117 if (m_false_alarms) {
118 if (m_hit_count >= m_false_alarms) {
119 m_hit_count -= m_false_alarms;
122 m_false_alarms -= m_hit_count;
128 // RETURNS - true if we should stop at this breakpoint, false if we
131 bool Watchpoint::ShouldStop(StoppointCallbackContext *context) {
137 void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) {
138 DumpWithLevel(s, level);
141 void Watchpoint::Dump(Stream *s) const {
142 DumpWithLevel(s, lldb::eDescriptionLevelBrief);
145 // If prefix is nullptr, we display the watch id and ignore the prefix
147 void Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const {
149 s->Printf("\nWatchpoint %u hit:", GetID());
153 if (m_old_value_sp) {
154 const char *old_value_cstr = m_old_value_sp->GetValueAsCString();
155 if (old_value_cstr && old_value_cstr[0])
156 s->Printf("\n%sold value: %s", prefix, old_value_cstr);
158 const char *old_summary_cstr = m_old_value_sp->GetSummaryAsCString();
159 if (old_summary_cstr && old_summary_cstr[0])
160 s->Printf("\n%sold value: %s", prefix, old_summary_cstr);
164 if (m_new_value_sp) {
165 const char *new_value_cstr = m_new_value_sp->GetValueAsCString();
166 if (new_value_cstr && new_value_cstr[0])
167 s->Printf("\n%snew value: %s", prefix, new_value_cstr);
169 const char *new_summary_cstr = m_new_value_sp->GetSummaryAsCString();
170 if (new_summary_cstr && new_summary_cstr[0])
171 s->Printf("\n%snew value: %s", prefix, new_summary_cstr);
176 void Watchpoint::DumpWithLevel(Stream *s,
177 lldb::DescriptionLevel description_level) const {
181 assert(description_level >= lldb::eDescriptionLevelBrief &&
182 description_level <= lldb::eDescriptionLevelVerbose);
184 s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64
185 " size = %u state = %s type = %s%s",
186 GetID(), GetLoadAddress(), m_byte_size,
187 IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "",
188 m_watch_write ? "w" : "");
190 if (description_level >= lldb::eDescriptionLevelFull) {
191 if (!m_decl_str.empty())
192 s->Printf("\n declare @ '%s'", m_decl_str.c_str());
193 if (!m_watch_spec_str.empty())
194 s->Printf("\n watchpoint spec = '%s'", m_watch_spec_str.c_str());
196 // Dump the snapshots we have taken.
197 DumpSnapshots(s, " ");
199 if (GetConditionText())
200 s->Printf("\n condition = '%s'", GetConditionText());
201 m_options.GetCallbackDescription(s, description_level);
204 if (description_level >= lldb::eDescriptionLevelVerbose) {
205 s->Printf("\n hw_index = %i hit_count = %-4u ignore_count = %-4u",
206 GetHardwareIndex(), GetHitCount(), GetIgnoreCount());
210 bool Watchpoint::IsEnabled() const { return m_enabled; }
212 // Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
213 // temporarily disable the watchpoint in order to perform possible watchpoint
214 // actions without triggering further watchpoint events. After the temporary
215 // disabled watchpoint is enabled, we then turn off the ephemeral mode.
217 void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; }
219 void Watchpoint::TurnOffEphemeralMode() {
220 m_is_ephemeral = false;
221 // Leaving ephemeral mode, reset the m_disabled_count!
222 m_disabled_count = 0;
225 bool Watchpoint::IsDisabledDuringEphemeralMode() {
226 return m_disabled_count > 1 && m_is_ephemeral;
229 void Watchpoint::SetEnabled(bool enabled, bool notify) {
232 SetHardwareIndex(LLDB_INVALID_INDEX32);
236 // Don't clear the snapshots for now.
237 // Within StopInfo.cpp, we purposely do disable/enable watchpoint while
238 // performing watchpoint actions.
240 bool changed = enabled != m_enabled;
242 if (notify && !m_is_ephemeral && changed)
243 SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled
244 : eWatchpointEventTypeDisabled);
247 void Watchpoint::SetWatchpointType(uint32_t type, bool notify) {
248 int old_watch_read = m_watch_read;
249 int old_watch_write = m_watch_write;
250 m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
251 m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
253 (old_watch_read != m_watch_read || old_watch_write != m_watch_write))
254 SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged);
257 bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; }
259 bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; }
261 uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; }
263 void Watchpoint::SetIgnoreCount(uint32_t n) {
264 bool changed = m_ignore_count != n;
267 SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged);
270 bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) {
271 return m_options.InvokeCallback(context, GetID());
274 void Watchpoint::SetCondition(const char *condition) {
275 if (condition == nullptr || condition[0] == '\0') {
276 if (m_condition_ap.get())
277 m_condition_ap.reset();
279 // Pass nullptr for expr_prefix (no translation-unit level definitions).
281 m_condition_ap.reset(m_target.GetUserExpressionForLanguage(
282 condition, llvm::StringRef(), lldb::eLanguageTypeUnknown,
283 UserExpression::eResultTypeAny, EvaluateExpressionOptions(), error));
285 // FIXME: Log something...
286 m_condition_ap.reset();
289 SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged);
292 const char *Watchpoint::GetConditionText() const {
293 if (m_condition_ap.get())
294 return m_condition_ap->GetUserText();
299 void Watchpoint::SendWatchpointChangedEvent(
300 lldb::WatchpointEventType eventKind) {
301 if (!m_being_created &&
302 GetTarget().EventTypeHasListeners(
303 Target::eBroadcastBitWatchpointChanged)) {
304 WatchpointEventData *data =
305 new Watchpoint::WatchpointEventData(eventKind, shared_from_this());
306 GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
310 void Watchpoint::SendWatchpointChangedEvent(WatchpointEventData *data) {
314 if (!m_being_created &&
315 GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
316 GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
321 Watchpoint::WatchpointEventData::WatchpointEventData(
322 WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
323 : EventData(), m_watchpoint_event(sub_type),
324 m_new_watchpoint_sp(new_watchpoint_sp) {}
326 Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
328 const ConstString &Watchpoint::WatchpointEventData::GetFlavorString() {
329 static ConstString g_flavor("Watchpoint::WatchpointEventData");
333 const ConstString &Watchpoint::WatchpointEventData::GetFlavor() const {
334 return WatchpointEventData::GetFlavorString();
337 WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() {
338 return m_new_watchpoint_sp;
342 Watchpoint::WatchpointEventData::GetWatchpointEventType() const {
343 return m_watchpoint_event;
346 void Watchpoint::WatchpointEventData::Dump(Stream *s) const {}
348 const Watchpoint::WatchpointEventData *
349 Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) {
351 const EventData *event_data = event->GetData();
353 event_data->GetFlavor() == WatchpointEventData::GetFlavorString())
354 return static_cast<const WatchpointEventData *>(event->GetData());
360 Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
361 const EventSP &event_sp) {
362 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
365 return eWatchpointEventTypeInvalidType;
367 return data->GetWatchpointEventType();
370 WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
371 const EventSP &event_sp) {
374 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
376 wp_sp = data->m_new_watchpoint_sp;