contrib/llvm/tools/lldb/source/Breakpoint/Watchpoint.cpp

   1 //===-- Watchpoint.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Breakpoint/Watchpoint.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  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/Symbol/ClangASTContext.h"
  22 #include "lldb/Target/Process.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Target/ThreadSpec.h"
  25 #include "lldb/Expression/ClangUserExpression.h"
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29
  30 Watchpoint::Watchpoint (Target& target, lldb::addr_t addr, uint32_t size, const ClangASTType *type, bool hardware) :
  31     StoppointLocation (0, addr, size, hardware),
  32     m_target(target),
  33     m_enabled(false),
  34     m_is_hardware(hardware),
  35     m_is_watch_variable(false),
  36     m_is_ephemeral(false),
  37     m_disabled_count(0),
  38     m_watch_read(0),
  39     m_watch_write(0),
  40     m_watch_was_read(0),
  41     m_watch_was_written(0),
  42     m_ignore_count(0),
  43     m_false_alarms(0),
  44     m_decl_str(),
  45     m_watch_spec_str(),
  46     m_type(),
  47     m_error(),
  48     m_options (),
  49     m_being_created(true)
  50 {
  51     if (type && type->IsValid())
  52         m_type = *type;
  53     else
  54     {
  55         // If we don't have a known type, then we force it to unsigned int of the right size.
  56         ClangASTContext *ast_context = target.GetScratchClangASTContext();
  57         m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8 * size);
  58     }
  59
  60     // Set the initial value of the watched variable:
  61     if (m_target.GetProcessSP())
  62     {
  63         ExecutionContext exe_ctx;
  64         m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
  65         CaptureWatchedValue (exe_ctx);
  66     }
  67     m_being_created = false;
  68 }
  69
  70 Watchpoint::~Watchpoint()
  71 {
  72 }
  73
  74 // This function is used when "baton" doesn't need to be freed
  75 void
  76 Watchpoint::SetCallback (WatchpointHitCallback callback, void *baton, bool is_synchronous)
  77 {
  78     // The default "Baton" class will keep a copy of "baton" and won't free
  79     // or delete it when it goes goes out of scope.
  80     m_options.SetCallback(callback, BatonSP (new Baton(baton)), is_synchronous);
  81
  82     SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged);
  83 }
  84
  85 // This function is used when a baton needs to be freed and therefore is
  86 // contained in a "Baton" subclass.
  87 void
  88 Watchpoint::SetCallback (WatchpointHitCallback callback, const BatonSP &callback_baton_sp, bool is_synchronous)
  89 {
  90     m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
  91     SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged);
  92 }
  93
  94 void
  95 Watchpoint::ClearCallback ()
  96 {
  97     m_options.ClearCallback ();
  98     SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged);
  99 }
 100
 101 void
 102 Watchpoint::SetDeclInfo (const std::string &str)
 103 {
 104     m_decl_str = str;
 105     return;
 106 }
 107
 108 std::string
 109 Watchpoint::GetWatchSpec()
 110 {
 111     return m_watch_spec_str;
 112 }
 113
 114 void
 115 Watchpoint::SetWatchSpec (const std::string &str)
 116 {
 117     m_watch_spec_str = str;
 118     return;
 119 }
 120
 121 // Override default impl of StoppointLocation::IsHardware() since m_is_hardware
 122 // member field is more accurate.
 123 bool
 124 Watchpoint::IsHardware () const
 125 {
 126     return m_is_hardware;
 127 }
 128
 129 bool
 130 Watchpoint::IsWatchVariable() const
 131 {
 132     return m_is_watch_variable;
 133 }
 134
 135 void
 136 Watchpoint::SetWatchVariable(bool val)
 137 {
 138     m_is_watch_variable = val;
 139 }
 140
 141 bool
 142 Watchpoint::CaptureWatchedValue (const ExecutionContext &exe_ctx)
 143 {
 144     ConstString watch_name("$__lldb__watch_value");
 145     m_old_value_sp = m_new_value_sp;
 146     Address watch_address(GetLoadAddress());
 147     if (!m_type.IsValid())
 148     {
 149         // Don't know how to report new & old values, since we couldn't make a scalar type for this watchpoint.
 150         // This works around an assert in ValueObjectMemory::Create.
 151         // FIXME: This should not happen, but if it does in some case we care about,
 152         // we can go grab the value raw and print it as unsigned.
 153         return false;
 154     }
 155     m_new_value_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), watch_name.AsCString(), watch_address, m_type);
 156     m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name);
 157     if (m_new_value_sp && m_new_value_sp->GetError().Success())
 158         return true;
 159     else
 160         return false;
 161 }
 162
 163 void
 164 Watchpoint::IncrementFalseAlarmsAndReviseHitCount()
 165 {
 166     ++m_false_alarms;
 167     if (m_false_alarms)
 168     {
 169         if (m_hit_count >= m_false_alarms)
 170         {
 171             m_hit_count -= m_false_alarms;
 172             m_false_alarms = 0;
 173         }
 174         else
 175         {
 176             m_false_alarms -= m_hit_count;
 177             m_hit_count = 0;
 178         }
 179     }
 180 }
 181
 182 // RETURNS - true if we should stop at this breakpoint, false if we
 183 // should continue.
 184
 185 bool
 186 Watchpoint::ShouldStop (StoppointCallbackContext *context)
 187 {
 188     IncrementHitCount();
 189
 190     if (!IsEnabled())
 191         return false;
 192
 193     if (GetHitCount() <= GetIgnoreCount())
 194         return false;
 195
 196     return true;
 197 }
 198
 199 void
 200 Watchpoint::GetDescription (Stream *s, lldb::DescriptionLevel level)
 201 {
 202     DumpWithLevel(s, level);
 203     return;
 204 }
 205
 206 void
 207 Watchpoint::Dump(Stream *s) const
 208 {
 209     DumpWithLevel(s, lldb::eDescriptionLevelBrief);
 210 }
 211
 212 // If prefix is NULL, we display the watch id and ignore the prefix altogether.
 213 void
 214 Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const
 215 {
 216     if (!prefix)
 217     {
 218         s->Printf("\nWatchpoint %u hit:", GetID());
 219         prefix = "";
 220     }
 221
 222     if (m_old_value_sp)
 223     {
 224         s->Printf("\n%sold value: %s", prefix, m_old_value_sp->GetValueAsCString());
 225     }
 226     if (m_new_value_sp)
 227     {
 228         s->Printf("\n%snew value: %s", prefix, m_new_value_sp->GetValueAsCString());
 229     }
 230 }
 231
 232 void
 233 Watchpoint::DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const
 234 {
 235     if (s == NULL)
 236         return;
 237
 238     assert(description_level >= lldb::eDescriptionLevelBrief &&
 239            description_level <= lldb::eDescriptionLevelVerbose);
 240
 241     s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64 " size = %u state = %s type = %s%s",
 242               GetID(),
 243               GetLoadAddress(),
 244               m_byte_size,
 245               IsEnabled() ? "enabled" : "disabled",
 246               m_watch_read ? "r" : "",
 247               m_watch_write ? "w" : "");
 248
 249     if (description_level >= lldb::eDescriptionLevelFull) {
 250         if (!m_decl_str.empty())
 251             s->Printf("\n    declare @ '%s'", m_decl_str.c_str());
 252         if (!m_watch_spec_str.empty())
 253             s->Printf("\n    watchpoint spec = '%s'", m_watch_spec_str.c_str());
 254
 255         // Dump the snapshots we have taken.
 256         DumpSnapshots(s, "    ");
 257
 258         if (GetConditionText())
 259             s->Printf("\n    condition = '%s'", GetConditionText());
 260         m_options.GetCallbackDescription(s, description_level);
 261     }
 262
 263     if (description_level >= lldb::eDescriptionLevelVerbose)
 264     {
 265         s->Printf("\n    hw_index = %i  hit_count = %-4u  ignore_count = %-4u",
 266                   GetHardwareIndex(),
 267                   GetHitCount(),
 268                   GetIgnoreCount());
 269     }
 270 }
 271
 272 bool
 273 Watchpoint::IsEnabled() const
 274 {
 275     return m_enabled;
 276 }
 277
 278 // Within StopInfo.cpp, we purposely turn on the ephemeral mode right before temporarily disable the watchpoint
 279 // in order to perform possible watchpoint actions without triggering further watchpoint events.
 280 // After the temporary disabled watchpoint is enabled, we then turn off the ephemeral mode.
 281
 282 void
 283 Watchpoint::TurnOnEphemeralMode()
 284 {
 285     m_is_ephemeral = true;
 286 }
 287
 288 void
 289 Watchpoint::TurnOffEphemeralMode()
 290 {
 291     m_is_ephemeral = false;
 292     // Leaving ephemeral mode, reset the m_disabled_count!
 293     m_disabled_count = 0;
 294 }
 295
 296 bool
 297 Watchpoint::IsDisabledDuringEphemeralMode()
 298 {
 299     return m_disabled_count > 1;
 300 }
 301
 302 void
 303 Watchpoint::SetEnabled(bool enabled, bool notify)
 304 {
 305     if (!enabled)
 306     {
 307         if (!m_is_ephemeral)
 308             SetHardwareIndex(LLDB_INVALID_INDEX32);
 309         else
 310             ++m_disabled_count;
 311
 312         // Don't clear the snapshots for now.
 313         // Within StopInfo.cpp, we purposely do disable/enable watchpoint while performing watchpoint actions.
 314     }
 315     bool changed = enabled != m_enabled;
 316     m_enabled = enabled;
 317     if (notify && !m_is_ephemeral && changed)
 318         SendWatchpointChangedEvent (enabled ? eWatchpointEventTypeEnabled : eWatchpointEventTypeDisabled);
 319 }
 320
 321 void
 322 Watchpoint::SetWatchpointType (uint32_t type, bool notify)
 323 {
 324     int old_watch_read = m_watch_read;
 325     int old_watch_write = m_watch_write;
 326     m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
 327     m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
 328     if (notify && (old_watch_read != m_watch_read || old_watch_write != m_watch_write))
 329         SendWatchpointChangedEvent (eWatchpointEventTypeTypeChanged);
 330 }
 331
 332 bool
 333 Watchpoint::WatchpointRead () const
 334 {
 335     return m_watch_read != 0;
 336 }
 337 bool
 338 Watchpoint::WatchpointWrite () const
 339 {
 340     return m_watch_write != 0;
 341 }
 342 uint32_t
 343 Watchpoint::GetIgnoreCount () const
 344 {
 345     return m_ignore_count;
 346 }
 347
 348 void
 349 Watchpoint::SetIgnoreCount (uint32_t n)
 350 {
 351     bool changed = m_ignore_count != n;
 352     m_ignore_count = n;
 353     if (changed)
 354         SendWatchpointChangedEvent (eWatchpointEventTypeIgnoreChanged);
 355 }
 356
 357 bool
 358 Watchpoint::InvokeCallback (StoppointCallbackContext *context)
 359 {
 360     return m_options.InvokeCallback (context, GetID());
 361 }
 362
 363 void
 364 Watchpoint::SetCondition (const char *condition)
 365 {
 366     if (condition == NULL || condition[0] == '\0')
 367     {
 368         if (m_condition_ap.get())
 369             m_condition_ap.reset();
 370     }
 371     else
 372     {
 373         // Pass NULL for expr_prefix (no translation-unit level definitions).
 374         m_condition_ap.reset(new ClangUserExpression (condition, NULL, lldb::eLanguageTypeUnknown, ClangUserExpression::eResultTypeAny));
 375     }
 376     SendWatchpointChangedEvent (eWatchpointEventTypeConditionChanged);
 377 }
 378
 379 const char *
 380 Watchpoint::GetConditionText () const
 381 {
 382     if (m_condition_ap.get())
 383         return m_condition_ap->GetUserText();
 384     else
 385         return NULL;
 386 }
 387
 388 void
 389 Watchpoint::SendWatchpointChangedEvent (lldb::WatchpointEventType eventKind)
 390 {
 391     if (!m_being_created
 392         && GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
 393     {
 394         WatchpointEventData *data = new Watchpoint::WatchpointEventData (eventKind, shared_from_this());
 395         GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, data);
 396     }
 397 }
 398
 399 void
 400 Watchpoint::SendWatchpointChangedEvent (WatchpointEventData *data)
 401 {
 402
 403     if (data == NULL)
 404         return;
 405
 406     if (!m_being_created
 407         && GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
 408         GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, data);
 409     else
 410         delete data;
 411 }
 412
 413 Watchpoint::WatchpointEventData::WatchpointEventData (WatchpointEventType sub_type,
 414                                                       const WatchpointSP &new_watchpoint_sp) :
 415     EventData (),
 416     m_watchpoint_event (sub_type),
 417     m_new_watchpoint_sp (new_watchpoint_sp)
 418 {
 419 }
 420
 421 Watchpoint::WatchpointEventData::~WatchpointEventData ()
 422 {
 423 }
 424
 425 const ConstString &
 426 Watchpoint::WatchpointEventData::GetFlavorString ()
 427 {
 428     static ConstString g_flavor ("Watchpoint::WatchpointEventData");
 429     return g_flavor;
 430 }
 431
 432 const ConstString &
 433 Watchpoint::WatchpointEventData::GetFlavor () const
 434 {
 435     return WatchpointEventData::GetFlavorString ();
 436 }
 437
 438
 439 WatchpointSP &
 440 Watchpoint::WatchpointEventData::GetWatchpoint ()
 441 {
 442     return m_new_watchpoint_sp;
 443 }
 444
 445 WatchpointEventType
 446 Watchpoint::WatchpointEventData::GetWatchpointEventType () const
 447 {
 448     return m_watchpoint_event;
 449 }
 450
 451 void
 452 Watchpoint::WatchpointEventData::Dump (Stream *s) const
 453 {
 454 }
 455
 456 const Watchpoint::WatchpointEventData *
 457 Watchpoint::WatchpointEventData::GetEventDataFromEvent (const Event *event)
 458 {
 459     if (event)
 460     {
 461         const EventData *event_data = event->GetData();
 462         if (event_data && event_data->GetFlavor() == WatchpointEventData::GetFlavorString())
 463             return static_cast <const WatchpointEventData *> (event->GetData());
 464     }
 465     return NULL;
 466 }
 467
 468 WatchpointEventType
 469 Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent (const EventSP &event_sp)
 470 {
 471     const WatchpointEventData *data = GetEventDataFromEvent (event_sp.get());
 472
 473     if (data == NULL)
 474         return eWatchpointEventTypeInvalidType;
 475     else
 476         return data->GetWatchpointEventType();
 477 }
 478
 479 WatchpointSP
 480 Watchpoint::WatchpointEventData::GetWatchpointFromEvent (const EventSP &event_sp)
 481 {
 482     WatchpointSP wp_sp;
 483
 484     const WatchpointEventData *data = GetEventDataFromEvent (event_sp.get());
 485     if (data)
 486         wp_sp = data->m_new_watchpoint_sp;
 487
 488     return wp_sp;
 489 }