1 //===-- Watchpoint.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/Watchpoint.h" 10 11 #include "lldb/Breakpoint/StoppointCallbackContext.h" 12 #include "lldb/Core/Value.h" 13 #include "lldb/Core/ValueObject.h" 14 #include "lldb/Core/ValueObjectMemory.h" 15 #include "lldb/Expression/UserExpression.h" 16 #include "lldb/Symbol/TypeSystem.h" 17 #include "lldb/Target/Process.h" 18 #include "lldb/Target/Target.h" 19 #include "lldb/Target/ThreadSpec.h" 20 #include "lldb/Utility/LLDBLog.h" 21 #include "lldb/Utility/Log.h" 22 #include "lldb/Utility/Stream.h" 23 24 using namespace lldb; 25 using namespace lldb_private; 26 27 Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, 28 const CompilerType *type, bool hardware) 29 : StoppointSite(0, addr, size, hardware), m_target(target), 30 m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false), 31 m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0), 32 m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0), 33 m_ignore_count(0), m_false_alarms(0), m_being_created(true) { 34 35 if (type && type->IsValid()) 36 m_type = *type; 37 else { 38 // If we don't have a known type, then we force it to unsigned int of the 39 // right size. 40 auto type_system_or_err = 41 target.GetScratchTypeSystemForLanguage(eLanguageTypeC); 42 if (auto err = type_system_or_err.takeError()) { 43 LLDB_LOG_ERROR(GetLog(LLDBLog::Watchpoints), std::move(err), 44 "Failed to set type."); 45 } else { 46 m_type = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize( 47 eEncodingUint, 8 * size); 48 } 49 } 50 51 // Set the initial value of the watched variable: 52 if (m_target.GetProcessSP()) { 53 ExecutionContext exe_ctx; 54 m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx); 55 CaptureWatchedValue(exe_ctx); 56 } 57 m_being_created = false; 58 } 59 60 Watchpoint::~Watchpoint() = default; 61 62 // This function is used when "baton" doesn't need to be freed 63 void Watchpoint::SetCallback(WatchpointHitCallback callback, void *baton, 64 bool is_synchronous) { 65 // The default "Baton" class will keep a copy of "baton" and won't free or 66 // delete it when it goes goes out of scope. 67 m_options.SetCallback(callback, std::make_shared<UntypedBaton>(baton), 68 is_synchronous); 69 70 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged); 71 } 72 73 // This function is used when a baton needs to be freed and therefore is 74 // contained in a "Baton" subclass. 75 void Watchpoint::SetCallback(WatchpointHitCallback callback, 76 const BatonSP &callback_baton_sp, 77 bool is_synchronous) { 78 m_options.SetCallback(callback, callback_baton_sp, is_synchronous); 79 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged); 80 } 81 82 void Watchpoint::ClearCallback() { 83 m_options.ClearCallback(); 84 SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged); 85 } 86 87 void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; } 88 89 std::string Watchpoint::GetWatchSpec() { return m_watch_spec_str; } 90 91 void Watchpoint::SetWatchSpec(const std::string &str) { 92 m_watch_spec_str = str; 93 } 94 95 bool Watchpoint::IsHardware() const { 96 lldbassert(m_is_hardware || !HardwareRequired()); 97 return m_is_hardware; 98 } 99 100 bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; } 101 102 void Watchpoint::SetWatchVariable(bool val) { m_is_watch_variable = val; } 103 104 bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) { 105 ConstString watch_name("$__lldb__watch_value"); 106 m_old_value_sp = m_new_value_sp; 107 Address watch_address(GetLoadAddress()); 108 if (!m_type.IsValid()) { 109 // Don't know how to report new & old values, since we couldn't make a 110 // scalar type for this watchpoint. This works around an assert in 111 // ValueObjectMemory::Create. 112 // FIXME: This should not happen, but if it does in some case we care about, 113 // we can go grab the value raw and print it as unsigned. 114 return false; 115 } 116 m_new_value_sp = ValueObjectMemory::Create( 117 exe_ctx.GetBestExecutionContextScope(), watch_name.GetStringRef(), 118 watch_address, m_type); 119 m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name); 120 return (m_new_value_sp && m_new_value_sp->GetError().Success()); 121 } 122 123 void Watchpoint::IncrementFalseAlarmsAndReviseHitCount() { 124 ++m_false_alarms; 125 if (m_false_alarms) { 126 if (m_hit_counter.GetValue() >= m_false_alarms) { 127 m_hit_counter.Decrement(m_false_alarms); 128 m_false_alarms = 0; 129 } else { 130 m_false_alarms -= m_hit_counter.GetValue(); 131 m_hit_counter.Reset(); 132 } 133 } 134 } 135 136 // RETURNS - true if we should stop at this breakpoint, false if we 137 // should continue. 138 139 bool Watchpoint::ShouldStop(StoppointCallbackContext *context) { 140 m_hit_counter.Increment(); 141 142 return IsEnabled(); 143 } 144 145 void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) { 146 DumpWithLevel(s, level); 147 } 148 149 void Watchpoint::Dump(Stream *s) const { 150 DumpWithLevel(s, lldb::eDescriptionLevelBrief); 151 } 152 153 // If prefix is nullptr, we display the watch id and ignore the prefix 154 // altogether. 155 void Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const { 156 if (!prefix) { 157 s->Printf("\nWatchpoint %u hit:", GetID()); 158 prefix = ""; 159 } 160 161 if (m_old_value_sp) { 162 const char *old_value_cstr = m_old_value_sp->GetValueAsCString(); 163 if (old_value_cstr && old_value_cstr[0]) 164 s->Printf("\n%sold value: %s", prefix, old_value_cstr); 165 else { 166 const char *old_summary_cstr = m_old_value_sp->GetSummaryAsCString(); 167 if (old_summary_cstr && old_summary_cstr[0]) 168 s->Printf("\n%sold value: %s", prefix, old_summary_cstr); 169 } 170 } 171 172 if (m_new_value_sp) { 173 const char *new_value_cstr = m_new_value_sp->GetValueAsCString(); 174 if (new_value_cstr && new_value_cstr[0]) 175 s->Printf("\n%snew value: %s", prefix, new_value_cstr); 176 else { 177 const char *new_summary_cstr = m_new_value_sp->GetSummaryAsCString(); 178 if (new_summary_cstr && new_summary_cstr[0]) 179 s->Printf("\n%snew value: %s", prefix, new_summary_cstr); 180 } 181 } 182 } 183 184 void Watchpoint::DumpWithLevel(Stream *s, 185 lldb::DescriptionLevel description_level) const { 186 if (s == nullptr) 187 return; 188 189 assert(description_level >= lldb::eDescriptionLevelBrief && 190 description_level <= lldb::eDescriptionLevelVerbose); 191 192 s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64 193 " size = %u state = %s type = %s%s", 194 GetID(), GetLoadAddress(), m_byte_size, 195 IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "", 196 m_watch_write ? "w" : ""); 197 198 if (description_level >= lldb::eDescriptionLevelFull) { 199 if (!m_decl_str.empty()) 200 s->Printf("\n declare @ '%s'", m_decl_str.c_str()); 201 if (!m_watch_spec_str.empty()) 202 s->Printf("\n watchpoint spec = '%s'", m_watch_spec_str.c_str()); 203 204 // Dump the snapshots we have taken. 205 DumpSnapshots(s, " "); 206 207 if (GetConditionText()) 208 s->Printf("\n condition = '%s'", GetConditionText()); 209 m_options.GetCallbackDescription(s, description_level); 210 } 211 212 if (description_level >= lldb::eDescriptionLevelVerbose) { 213 s->Printf("\n hw_index = %i hit_count = %-4u ignore_count = %-4u", 214 GetHardwareIndex(), GetHitCount(), GetIgnoreCount()); 215 } 216 } 217 218 bool Watchpoint::IsEnabled() const { return m_enabled; } 219 220 // Within StopInfo.cpp, we purposely turn on the ephemeral mode right before 221 // temporarily disable the watchpoint in order to perform possible watchpoint 222 // actions without triggering further watchpoint events. After the temporary 223 // disabled watchpoint is enabled, we then turn off the ephemeral mode. 224 225 void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; } 226 227 void Watchpoint::TurnOffEphemeralMode() { 228 m_is_ephemeral = false; 229 // Leaving ephemeral mode, reset the m_disabled_count! 230 m_disabled_count = 0; 231 } 232 233 bool Watchpoint::IsDisabledDuringEphemeralMode() { 234 return m_disabled_count > 1 && m_is_ephemeral; 235 } 236 237 void Watchpoint::SetEnabled(bool enabled, bool notify) { 238 if (!enabled) { 239 if (!m_is_ephemeral) 240 SetHardwareIndex(LLDB_INVALID_INDEX32); 241 else 242 ++m_disabled_count; 243 244 // Don't clear the snapshots for now. 245 // Within StopInfo.cpp, we purposely do disable/enable watchpoint while 246 // performing watchpoint actions. 247 } 248 bool changed = enabled != m_enabled; 249 m_enabled = enabled; 250 if (notify && !m_is_ephemeral && changed) 251 SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled 252 : eWatchpointEventTypeDisabled); 253 } 254 255 void Watchpoint::SetWatchpointType(uint32_t type, bool notify) { 256 int old_watch_read = m_watch_read; 257 int old_watch_write = m_watch_write; 258 m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0; 259 m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0; 260 if (notify && 261 (old_watch_read != m_watch_read || old_watch_write != m_watch_write)) 262 SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged); 263 } 264 265 bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; } 266 267 bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; } 268 269 uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; } 270 271 void Watchpoint::SetIgnoreCount(uint32_t n) { 272 bool changed = m_ignore_count != n; 273 m_ignore_count = n; 274 if (changed) 275 SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged); 276 } 277 278 bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) { 279 return m_options.InvokeCallback(context, GetID()); 280 } 281 282 void Watchpoint::SetCondition(const char *condition) { 283 if (condition == nullptr || condition[0] == '\0') { 284 if (m_condition_up) 285 m_condition_up.reset(); 286 } else { 287 // Pass nullptr for expr_prefix (no translation-unit level definitions). 288 Status error; 289 m_condition_up.reset(m_target.GetUserExpressionForLanguage( 290 condition, llvm::StringRef(), lldb::eLanguageTypeUnknown, 291 UserExpression::eResultTypeAny, EvaluateExpressionOptions(), nullptr, 292 error)); 293 if (error.Fail()) { 294 // FIXME: Log something... 295 m_condition_up.reset(); 296 } 297 } 298 SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged); 299 } 300 301 const char *Watchpoint::GetConditionText() const { 302 if (m_condition_up) 303 return m_condition_up->GetUserText(); 304 else 305 return nullptr; 306 } 307 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); 316 } 317 } 318 319 void Watchpoint::SendWatchpointChangedEvent(WatchpointEventData *data) { 320 if (data == nullptr) 321 return; 322 323 if (!m_being_created && 324 GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged)) 325 GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data); 326 else 327 delete data; 328 } 329 330 Watchpoint::WatchpointEventData::WatchpointEventData( 331 WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp) 332 : m_watchpoint_event(sub_type), m_new_watchpoint_sp(new_watchpoint_sp) {} 333 334 Watchpoint::WatchpointEventData::~WatchpointEventData() = default; 335 336 ConstString Watchpoint::WatchpointEventData::GetFlavorString() { 337 static ConstString g_flavor("Watchpoint::WatchpointEventData"); 338 return g_flavor; 339 } 340 341 ConstString Watchpoint::WatchpointEventData::GetFlavor() const { 342 return WatchpointEventData::GetFlavorString(); 343 } 344 345 WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() { 346 return m_new_watchpoint_sp; 347 } 348 349 WatchpointEventType 350 Watchpoint::WatchpointEventData::GetWatchpointEventType() const { 351 return m_watchpoint_event; 352 } 353 354 void Watchpoint::WatchpointEventData::Dump(Stream *s) const {} 355 356 const Watchpoint::WatchpointEventData * 357 Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) { 358 if (event) { 359 const EventData *event_data = event->GetData(); 360 if (event_data && 361 event_data->GetFlavor() == WatchpointEventData::GetFlavorString()) 362 return static_cast<const WatchpointEventData *>(event->GetData()); 363 } 364 return nullptr; 365 } 366 367 WatchpointEventType 368 Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent( 369 const EventSP &event_sp) { 370 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get()); 371 372 if (data == nullptr) 373 return eWatchpointEventTypeInvalidType; 374 else 375 return data->GetWatchpointEventType(); 376 } 377 378 WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent( 379 const EventSP &event_sp) { 380 WatchpointSP wp_sp; 381 382 const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get()); 383 if (data) 384 wp_sp = data->m_new_watchpoint_sp; 385 386 return wp_sp; 387 } 388