source/Target/StopInfo.cpp

   1 //===-- StopInfo.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 // C Includes
  11 // C++ Includes
  12 #include <string>
  13
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Breakpoint/Breakpoint.h"
  17 #include "lldb/Breakpoint/BreakpointLocation.h"
  18 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  19 #include "lldb/Breakpoint/Watchpoint.h"
  20 #include "lldb/Core/Debugger.h"
  21 #include "lldb/Core/Log.h"
  22 #include "lldb/Core/StreamString.h"
  23 #include "lldb/Core/ValueObject.h"
  24 #include "lldb/Expression/UserExpression.h"
  25 #include "lldb/Target/Process.h"
  26 #include "lldb/Target/StopInfo.h"
  27 #include "lldb/Target/Target.h"
  28 #include "lldb/Target/Thread.h"
  29 #include "lldb/Target/ThreadPlan.h"
  30 #include "lldb/Target/UnixSignals.h"
  31
  32 using namespace lldb;
  33 using namespace lldb_private;
  34
  35 StopInfo::StopInfo(Thread &thread, uint64_t value)
  36     : m_thread_wp(thread.shared_from_this()),
  37       m_stop_id(thread.GetProcess()->GetStopID()),
  38       m_resume_id(thread.GetProcess()->GetResumeID()), m_value(value),
  39       m_description(), m_override_should_notify(eLazyBoolCalculate),
  40       m_override_should_stop(eLazyBoolCalculate), m_extended_info() {}
  41
  42 bool StopInfo::IsValid() const {
  43   ThreadSP thread_sp(m_thread_wp.lock());
  44   if (thread_sp)
  45     return thread_sp->GetProcess()->GetStopID() == m_stop_id;
  46   return false;
  47 }
  48
  49 void StopInfo::MakeStopInfoValid() {
  50   ThreadSP thread_sp(m_thread_wp.lock());
  51   if (thread_sp) {
  52     m_stop_id = thread_sp->GetProcess()->GetStopID();
  53     m_resume_id = thread_sp->GetProcess()->GetResumeID();
  54   }
  55 }
  56
  57 bool StopInfo::HasTargetRunSinceMe() {
  58   ThreadSP thread_sp(m_thread_wp.lock());
  59
  60   if (thread_sp) {
  61     lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
  62     if (ret_type == eStateRunning) {
  63       return true;
  64     } else if (ret_type == eStateStopped) {
  65       // This is a little tricky.  We want to count "run and stopped again
  66       // before you could
  67       // ask this question as a "TRUE" answer to HasTargetRunSinceMe.  But we
  68       // don't want to
  69       // include any running of the target done for expressions.  So we track
  70       // both resumes,
  71       // and resumes caused by expressions, and check if there are any resumes
  72       // NOT caused
  73       // by expressions.
  74
  75       uint32_t curr_resume_id = thread_sp->GetProcess()->GetResumeID();
  76       uint32_t last_user_expression_id =
  77           thread_sp->GetProcess()->GetLastUserExpressionResumeID();
  78       if (curr_resume_id == m_resume_id) {
  79         return false;
  80       } else if (curr_resume_id > last_user_expression_id) {
  81         return true;
  82       }
  83     }
  84   }
  85   return false;
  86 }
  87
  88 //----------------------------------------------------------------------
  89 // StopInfoBreakpoint
  90 //----------------------------------------------------------------------
  91
  92 namespace lldb_private {
  93 class StopInfoBreakpoint : public StopInfo {
  94 public:
  95   StopInfoBreakpoint(Thread &thread, break_id_t break_id)
  96       : StopInfo(thread, break_id), m_should_stop(false),
  97         m_should_stop_is_valid(false), m_should_perform_action(true),
  98         m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
  99         m_was_one_shot(false) {
 100     StoreBPInfo();
 101   }
 102
 103   StopInfoBreakpoint(Thread &thread, break_id_t break_id, bool should_stop)
 104       : StopInfo(thread, break_id), m_should_stop(should_stop),
 105         m_should_stop_is_valid(true), m_should_perform_action(true),
 106         m_address(LLDB_INVALID_ADDRESS), m_break_id(LLDB_INVALID_BREAK_ID),
 107         m_was_one_shot(false) {
 108     StoreBPInfo();
 109   }
 110
 111   ~StopInfoBreakpoint() override = default;
 112
 113   void StoreBPInfo() {
 114     ThreadSP thread_sp(m_thread_wp.lock());
 115     if (thread_sp) {
 116       BreakpointSiteSP bp_site_sp(
 117           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
 118       if (bp_site_sp) {
 119         if (bp_site_sp->GetNumberOfOwners() == 1) {
 120           BreakpointLocationSP bp_loc_sp = bp_site_sp->GetOwnerAtIndex(0);
 121           if (bp_loc_sp) {
 122             m_break_id = bp_loc_sp->GetBreakpoint().GetID();
 123             m_was_one_shot = bp_loc_sp->GetBreakpoint().IsOneShot();
 124           }
 125         }
 126         m_address = bp_site_sp->GetLoadAddress();
 127       }
 128     }
 129   }
 130
 131   bool IsValidForOperatingSystemThread(Thread &thread) override {
 132     ProcessSP process_sp(thread.GetProcess());
 133     if (process_sp) {
 134       BreakpointSiteSP bp_site_sp(
 135           process_sp->GetBreakpointSiteList().FindByID(m_value));
 136       if (bp_site_sp)
 137         return bp_site_sp->ValidForThisThread(&thread);
 138     }
 139     return false;
 140   }
 141
 142   StopReason GetStopReason() const override { return eStopReasonBreakpoint; }
 143
 144   bool ShouldStopSynchronous(Event *event_ptr) override {
 145     ThreadSP thread_sp(m_thread_wp.lock());
 146     if (thread_sp) {
 147       if (!m_should_stop_is_valid) {
 148         // Only check once if we should stop at a breakpoint
 149         BreakpointSiteSP bp_site_sp(
 150             thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
 151         if (bp_site_sp) {
 152           ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
 153           StoppointCallbackContext context(event_ptr, exe_ctx, true);
 154           bp_site_sp->BumpHitCounts();
 155           m_should_stop = bp_site_sp->ShouldStop(&context);
 156         } else {
 157           Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 158
 159           if (log)
 160             log->Printf(
 161                 "Process::%s could not find breakpoint site id: %" PRId64 "...",
 162                 __FUNCTION__, m_value);
 163
 164           m_should_stop = true;
 165         }
 166         m_should_stop_is_valid = true;
 167       }
 168       return m_should_stop;
 169     }
 170     return false;
 171   }
 172
 173   bool DoShouldNotify(Event *event_ptr) override {
 174     ThreadSP thread_sp(m_thread_wp.lock());
 175     if (thread_sp) {
 176       BreakpointSiteSP bp_site_sp(
 177           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
 178       if (bp_site_sp) {
 179         bool all_internal = true;
 180
 181         for (uint32_t i = 0; i < bp_site_sp->GetNumberOfOwners(); i++) {
 182           if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
 183             all_internal = false;
 184             break;
 185           }
 186         }
 187         return !all_internal;
 188       }
 189     }
 190     return true;
 191   }
 192
 193   const char *GetDescription() override {
 194     if (m_description.empty()) {
 195       ThreadSP thread_sp(m_thread_wp.lock());
 196       if (thread_sp) {
 197         BreakpointSiteSP bp_site_sp(
 198             thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
 199         if (bp_site_sp) {
 200           StreamString strm;
 201           // If we have just hit an internal breakpoint, and it has a kind
 202           // description, print that instead of the
 203           // full breakpoint printing:
 204           if (bp_site_sp->IsInternal()) {
 205             size_t num_owners = bp_site_sp->GetNumberOfOwners();
 206             for (size_t idx = 0; idx < num_owners; idx++) {
 207               const char *kind = bp_site_sp->GetOwnerAtIndex(idx)
 208                                      ->GetBreakpoint()
 209                                      .GetBreakpointKind();
 210               if (kind != nullptr) {
 211                 m_description.assign(kind);
 212                 return kind;
 213               }
 214             }
 215           }
 216
 217           strm.Printf("breakpoint ");
 218           bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
 219           m_description = strm.GetString();
 220         } else {
 221           StreamString strm;
 222           if (m_break_id != LLDB_INVALID_BREAK_ID) {
 223             BreakpointSP break_sp =
 224                 thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
 225                     m_break_id);
 226             if (break_sp) {
 227               if (break_sp->IsInternal()) {
 228                 const char *kind = break_sp->GetBreakpointKind();
 229                 if (kind)
 230                   strm.Printf("internal %s breakpoint(%d).", kind, m_break_id);
 231                 else
 232                   strm.Printf("internal breakpoint(%d).", m_break_id);
 233               } else {
 234                 strm.Printf("breakpoint %d.", m_break_id);
 235               }
 236             } else {
 237               if (m_was_one_shot)
 238                 strm.Printf("one-shot breakpoint %d", m_break_id);
 239               else
 240                 strm.Printf("breakpoint %d which has been deleted.",
 241                             m_break_id);
 242             }
 243           } else if (m_address == LLDB_INVALID_ADDRESS)
 244             strm.Printf("breakpoint site %" PRIi64
 245                         " which has been deleted - unknown address",
 246                         m_value);
 247           else
 248             strm.Printf("breakpoint site %" PRIi64
 249                         " which has been deleted - was at 0x%" PRIx64,
 250                         m_value, m_address);
 251
 252           m_description = strm.GetString();
 253         }
 254       }
 255     }
 256     return m_description.c_str();
 257   }
 258
 259 protected:
 260   bool ShouldStop(Event *event_ptr) override {
 261     // This just reports the work done by PerformAction or the synchronous stop.
 262     // It should
 263     // only ever get called after they have had a chance to run.
 264     assert(m_should_stop_is_valid);
 265     return m_should_stop;
 266   }
 267
 268   void PerformAction(Event *event_ptr) override {
 269     if (!m_should_perform_action)
 270       return;
 271     m_should_perform_action = false;
 272
 273     ThreadSP thread_sp(m_thread_wp.lock());
 274
 275     if (thread_sp) {
 276       Log *log = lldb_private::GetLogIfAnyCategoriesSet(
 277           LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_STEP);
 278
 279       if (!thread_sp->IsValid()) {
 280         // This shouldn't ever happen, but just in case, don't do more harm.
 281         if (log) {
 282           log->Printf("PerformAction got called with an invalid thread.");
 283         }
 284         m_should_stop = true;
 285         m_should_stop_is_valid = true;
 286         return;
 287       }
 288
 289       BreakpointSiteSP bp_site_sp(
 290           thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
 291       std::unordered_set<break_id_t> precondition_breakpoints;
 292
 293       if (bp_site_sp) {
 294         // Let's copy the owners list out of the site and store them in a local
 295         // list.  That way if
 296         // one of the breakpoint actions changes the site, then we won't be
 297         // operating on a bad list.
 298         BreakpointLocationCollection site_locations;
 299         size_t num_owners = bp_site_sp->CopyOwnersList(site_locations);
 300
 301         if (num_owners == 0) {
 302           m_should_stop = true;
 303         } else {
 304           // We go through each location, and test first its precondition - this
 305           // overrides everything.  Note,
 306           // we only do this once per breakpoint - not once per location...
 307           // Then check the condition.  If the condition says to stop,
 308           // then we run the callback for that location.  If that callback says
 309           // to stop as well, then
 310           // we set m_should_stop to true; we are going to stop.
 311           // But we still want to give all the breakpoints whose conditions say
 312           // we are going to stop a
 313           // chance to run their callbacks.
 314           // Of course if any callback restarts the target by putting "continue"
 315           // in the callback, then
 316           // we're going to restart, without running the rest of the callbacks.
 317           // And in this case we will
 318           // end up not stopping even if another location said we should stop.
 319           // But that's better than not
 320           // running all the callbacks.
 321
 322           m_should_stop = false;
 323
 324           // We don't select threads as we go through them testing breakpoint
 325           // conditions and running commands.
 326           // So we need to set the thread for expression evaluation here:
 327           ThreadList::ExpressionExecutionThreadPusher thread_pusher(thread_sp);
 328
 329           ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
 330           Process *process = exe_ctx.GetProcessPtr();
 331           if (process->GetModIDRef().IsLastResumeForUserExpression()) {
 332             // If we are in the middle of evaluating an expression, don't run
 333             // asynchronous breakpoint commands or
 334             // expressions.  That could lead to infinite recursion if the
 335             // command or condition re-calls the function
 336             // with this breakpoint.
 337             // TODO: We can keep a list of the breakpoints we've seen while
 338             // running expressions in the nested
 339             // PerformAction calls that can arise when the action runs a
 340             // function that hits another breakpoint,
 341             // and only stop running commands when we see the same breakpoint
 342             // hit a second time.
 343
 344             m_should_stop_is_valid = true;
 345             if (log)
 346               log->Printf("StopInfoBreakpoint::PerformAction - Hit a "
 347                           "breakpoint while running an expression,"
 348                           " not running commands to avoid recursion.");
 349             bool ignoring_breakpoints =
 350                 process->GetIgnoreBreakpointsInExpressions();
 351             if (ignoring_breakpoints) {
 352               m_should_stop = false;
 353               // Internal breakpoints will always stop.
 354               for (size_t j = 0; j < num_owners; j++) {
 355                 lldb::BreakpointLocationSP bp_loc_sp =
 356                     bp_site_sp->GetOwnerAtIndex(j);
 357                 if (bp_loc_sp->GetBreakpoint().IsInternal()) {
 358                   m_should_stop = true;
 359                   break;
 360                 }
 361               }
 362             } else {
 363               m_should_stop = true;
 364             }
 365             if (log)
 366               log->Printf("StopInfoBreakpoint::PerformAction - in expression, "
 367                           "continuing: %s.",
 368                           m_should_stop ? "true" : "false");
 369             process->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
 370                 "Warning: hit breakpoint while "
 371                 "running function, skipping commands and conditions to prevent "
 372                 "recursion.");
 373             return;
 374           }
 375
 376           StoppointCallbackContext context(event_ptr, exe_ctx, false);
 377
 378           // For safety's sake let's also grab an extra reference to the
 379           // breakpoint owners of the locations we're
 380           // going to examine, since the locations are going to have to get back
 381           // to their breakpoints, and the
 382           // locations don't keep their owners alive.  I'm just sticking the
 383           // BreakpointSP's in a vector since
 384           // I'm only using it to locally increment their retain counts.
 385
 386           std::vector<lldb::BreakpointSP> location_owners;
 387
 388           for (size_t j = 0; j < num_owners; j++) {
 389             BreakpointLocationSP loc(site_locations.GetByIndex(j));
 390             location_owners.push_back(loc->GetBreakpoint().shared_from_this());
 391           }
 392
 393           for (size_t j = 0; j < num_owners; j++) {
 394             lldb::BreakpointLocationSP bp_loc_sp = site_locations.GetByIndex(j);
 395
 396             // If another action disabled this breakpoint or its location, then
 397             // don't run the actions.
 398             if (!bp_loc_sp->IsEnabled() ||
 399                 !bp_loc_sp->GetBreakpoint().IsEnabled())
 400               continue;
 401
 402             // The breakpoint site may have many locations associated with it,
 403             // not all of them valid for
 404             // this thread.  Skip the ones that aren't:
 405             if (!bp_loc_sp->ValidForThisThread(thread_sp.get())) {
 406               if (log) {
 407                 StreamString s;
 408                 bp_loc_sp->GetDescription(&s, eDescriptionLevelBrief);
 409                 log->Printf("Breakpoint %s hit on thread 0x%llx but it was not "
 410                             "for this thread, continuing.",
 411                             s.GetData(), static_cast<unsigned long long>(
 412                                              thread_sp->GetID()));
 413               }
 414               continue;
 415             }
 416
 417             // First run the precondition, but since the precondition is per
 418             // breakpoint, only run it once
 419             // per breakpoint.
 420             std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
 421                 precondition_breakpoints.insert(
 422                     bp_loc_sp->GetBreakpoint().GetID());
 423             if (!result.second)
 424               continue;
 425
 426             bool precondition_result =
 427                 bp_loc_sp->GetBreakpoint().EvaluatePrecondition(context);
 428             if (!precondition_result)
 429               continue;
 430
 431             // Next run the condition for the breakpoint.  If that says we
 432             // should stop, then we'll run
 433             // the callback for the breakpoint.  If the callback says we
 434             // shouldn't stop that will win.
 435
 436             if (bp_loc_sp->GetConditionText() != nullptr) {
 437               Error condition_error;
 438               bool condition_says_stop =
 439                   bp_loc_sp->ConditionSaysStop(exe_ctx, condition_error);
 440
 441               if (!condition_error.Success()) {
 442                 Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
 443                 StreamSP error_sp = debugger.GetAsyncErrorStream();
 444                 error_sp->Printf("Stopped due to an error evaluating condition "
 445                                  "of breakpoint ");
 446                 bp_loc_sp->GetDescription(error_sp.get(),
 447                                           eDescriptionLevelBrief);
 448                 error_sp->Printf(": \"%s\"", bp_loc_sp->GetConditionText());
 449                 error_sp->EOL();
 450                 const char *err_str =
 451                     condition_error.AsCString("<Unknown Error>");
 452                 if (log)
 453                   log->Printf("Error evaluating condition: \"%s\"\n", err_str);
 454
 455                 error_sp->PutCString(err_str);
 456                 error_sp->EOL();
 457                 error_sp->Flush();
 458               } else {
 459                 if (log) {
 460                   StreamString s;
 461                   bp_loc_sp->GetDescription(&s, eDescriptionLevelBrief);
 462                   log->Printf("Condition evaluated for breakpoint %s on thread "
 463                               "0x%llx conditon_says_stop: %i.",
 464                               s.GetData(), static_cast<unsigned long long>(
 465                                                thread_sp->GetID()),
 466                               condition_says_stop);
 467                 }
 468                 if (!condition_says_stop) {
 469                   // We don't want to increment the hit count of breakpoints if
 470                   // the condition fails.
 471                   // We've already bumped it by the time we get here, so undo
 472                   // the bump:
 473                   bp_loc_sp->UndoBumpHitCount();
 474                   continue;
 475                 }
 476               }
 477             }
 478
 479             bool callback_says_stop;
 480
 481             // FIXME: For now the callbacks have to run in async mode - the
 482             // first time we restart we need
 483             // to get out of there.  So set it here.
 484             // When we figure out how to nest breakpoint hits then this will
 485             // change.
 486
 487             Debugger &debugger = thread_sp->CalculateTarget()->GetDebugger();
 488             bool old_async = debugger.GetAsyncExecution();
 489             debugger.SetAsyncExecution(true);
 490
 491             callback_says_stop = bp_loc_sp->InvokeCallback(&context);
 492
 493             debugger.SetAsyncExecution(old_async);
 494
 495             if (callback_says_stop)
 496               m_should_stop = true;
 497
 498             // If we are going to stop for this breakpoint, then remove the
 499             // breakpoint.
 500             if (callback_says_stop && bp_loc_sp &&
 501                 bp_loc_sp->GetBreakpoint().IsOneShot()) {
 502               thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
 503                   bp_loc_sp->GetBreakpoint().GetID());
 504             }
 505
 506             // Also make sure that the callback hasn't continued the target.
 507             // If it did, when we'll set m_should_start to false and get out of
 508             // here.
 509             if (HasTargetRunSinceMe()) {
 510               m_should_stop = false;
 511               break;
 512             }
 513           }
 514         }
 515         // We've figured out what this stop wants to do, so mark it as valid so
 516         // we don't compute it again.
 517         m_should_stop_is_valid = true;
 518       } else {
 519         m_should_stop = true;
 520         m_should_stop_is_valid = true;
 521         Log *log_process(
 522             lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 523
 524         if (log_process)
 525           log_process->Printf(
 526               "Process::%s could not find breakpoint site id: %" PRId64 "...",
 527               __FUNCTION__, m_value);
 528       }
 529       if (log)
 530         log->Printf("Process::%s returning from action with m_should_stop: %d.",
 531                     __FUNCTION__, m_should_stop);
 532     }
 533   }
 534
 535 private:
 536   bool m_should_stop;
 537   bool m_should_stop_is_valid;
 538   bool m_should_perform_action; // Since we are trying to preserve the "state"
 539                                 // of the system even if we run functions
 540   // etc. behind the users backs, we need to make sure we only REALLY perform
 541   // the action once.
 542   lldb::addr_t m_address; // We use this to capture the breakpoint site address
 543                           // when we create the StopInfo,
 544   // in case somebody deletes it between the time the StopInfo is made and the
 545   // description is asked for.
 546   lldb::break_id_t m_break_id;
 547   bool m_was_one_shot;
 548 };
 549
 550 //----------------------------------------------------------------------
 551 // StopInfoWatchpoint
 552 //----------------------------------------------------------------------
 553
 554 class StopInfoWatchpoint : public StopInfo {
 555 public:
 556   // Make sure watchpoint is properly disabled and subsequently enabled while
 557   // performing watchpoint actions.
 558   class WatchpointSentry {
 559   public:
 560     WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp),
 561                      watchpoint_sp(w_sp) {
 562       if (process_sp && watchpoint_sp) {
 563         const bool notify = false;
 564         watchpoint_sp->TurnOnEphemeralMode();
 565         process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
 566         process_sp->AddPreResumeAction(SentryPreResumeAction, this);
 567       }
 568     }
 569
 570     void DoReenable() {
 571       if (process_sp && watchpoint_sp) {
 572         bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode();
 573         watchpoint_sp->TurnOffEphemeralMode();
 574         const bool notify = false;
 575         if (was_disabled) {
 576           process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
 577         } else {
 578           process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
 579         }
 580       }
 581     }
 582
 583     ~WatchpointSentry() {
 584         DoReenable();
 585         if (process_sp)
 586             process_sp->ClearPreResumeAction(SentryPreResumeAction, this);
 587     }
 588
 589     static bool SentryPreResumeAction(void *sentry_void) {
 590         WatchpointSentry *sentry = (WatchpointSentry *) sentry_void;
 591         sentry->DoReenable();
 592         return true;
 593     }
 594
 595   private:
 596     ProcessSP process_sp;
 597     WatchpointSP watchpoint_sp;
 598   };
 599
 600   StopInfoWatchpoint(Thread &thread, break_id_t watch_id,
 601                      lldb::addr_t watch_hit_addr)
 602       : StopInfo(thread, watch_id), m_should_stop(false),
 603         m_should_stop_is_valid(false), m_watch_hit_addr(watch_hit_addr) {}
 604
 605   ~StopInfoWatchpoint() override = default;
 606
 607   StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
 608
 609   const char *GetDescription() override {
 610     if (m_description.empty()) {
 611       StreamString strm;
 612       strm.Printf("watchpoint %" PRIi64, m_value);
 613       m_description = strm.GetString();
 614     }
 615     return m_description.c_str();
 616   }
 617
 618 protected:
 619   bool ShouldStopSynchronous(Event *event_ptr) override {
 620     // ShouldStop() method is idempotent and should not affect hit count.
 621     // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
 622     // -->Process()::ShouldBroadcastEvent()->ThreadList::ShouldStop()->
 623     // Thread::ShouldStop()->ThreadPlanBase::ShouldStop()->
 624     // StopInfoWatchpoint::ShouldStop() and
 625     // Event::DoOnRemoval()->Process::ProcessEventData::DoOnRemoval()->
 626     // StopInfoWatchpoint::PerformAction().
 627     if (m_should_stop_is_valid)
 628       return m_should_stop;
 629
 630     ThreadSP thread_sp(m_thread_wp.lock());
 631     if (thread_sp) {
 632       WatchpointSP wp_sp(
 633           thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
 634               GetValue()));
 635       if (wp_sp) {
 636         // Check if we should stop at a watchpoint.
 637         ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
 638         StoppointCallbackContext context(event_ptr, exe_ctx, true);
 639         m_should_stop = wp_sp->ShouldStop(&context);
 640       } else {
 641         Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 642
 643         if (log)
 644           log->Printf(
 645               "Process::%s could not find watchpoint location id: %" PRId64
 646               "...",
 647               __FUNCTION__, GetValue());
 648
 649         m_should_stop = true;
 650       }
 651     }
 652     m_should_stop_is_valid = true;
 653     return m_should_stop;
 654   }
 655
 656   bool ShouldStop(Event *event_ptr) override {
 657     // This just reports the work done by PerformAction or the synchronous stop.
 658     // It should
 659     // only ever get called after they have had a chance to run.
 660     assert(m_should_stop_is_valid);
 661     return m_should_stop;
 662   }
 663
 664   void PerformAction(Event *event_ptr) override {
 665     Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS);
 666     // We're going to calculate if we should stop or not in some way during the
 667     // course of
 668     // this code.  Also by default we're going to stop, so set that here.
 669     m_should_stop = true;
 670
 671
 672     ThreadSP thread_sp(m_thread_wp.lock());
 673     if (thread_sp) {
 674
 675       WatchpointSP wp_sp(
 676           thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
 677               GetValue()));
 678       if (wp_sp) {
 679         ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
 680         ProcessSP process_sp = exe_ctx.GetProcessSP();
 681
 682         {
 683           // check if this process is running on an architecture where
 684           // watchpoints trigger
 685           // before the associated instruction runs. if so, disable the WP,
 686           // single-step and then
 687           // re-enable the watchpoint
 688           if (process_sp) {
 689             uint32_t num;
 690             bool wp_triggers_after;
 691
 692             if (process_sp->GetWatchpointSupportInfo(num, wp_triggers_after)
 693                     .Success()) {
 694               if (!wp_triggers_after) {
 695                 // We need to preserve the watch_index before watchpoint
 696                 // is disable. Since Watchpoint::SetEnabled will clear the
 697                 // watch index.
 698                 // This will fix TestWatchpointIter failure
 699                 Watchpoint *wp = wp_sp.get();
 700                 uint32_t watch_index = wp->GetHardwareIndex();
 701                 process_sp->DisableWatchpoint(wp, false);
 702                 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
 703                 assert(stored_stop_info_sp.get() == this);
 704
 705                 ThreadPlanSP new_plan_sp(
 706                     thread_sp->QueueThreadPlanForStepSingleInstruction(
 707                         false,  // step-over
 708                         false,  // abort_other_plans
 709                         true)); // stop_other_threads
 710                 new_plan_sp->SetIsMasterPlan(true);
 711                 new_plan_sp->SetOkayToDiscard(false);
 712                 new_plan_sp->SetPrivate(true);
 713                 process_sp->GetThreadList().SetSelectedThreadByID(
 714                     thread_sp->GetID());
 715                 process_sp->ResumeSynchronous(nullptr);
 716                 process_sp->GetThreadList().SetSelectedThreadByID(
 717                     thread_sp->GetID());
 718                 thread_sp->SetStopInfo(stored_stop_info_sp);
 719                 process_sp->EnableWatchpoint(wp, false);
 720                 wp->SetHardwareIndex(watch_index);
 721               }
 722             }
 723           }
 724         }
 725
 726         // This sentry object makes sure the current watchpoint is disabled
 727         // while performing watchpoint actions,
 728         // and it is then enabled after we are finished.
 729         WatchpointSentry sentry(process_sp, wp_sp);
 730
 731         /*
 732          * MIPS: Last 3bits of the watchpoint address are masked by the kernel.
 733          * For example:
 734          * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is
 735          * set at 'm', then
 736          * watch exception is generated even when 'n' is read/written. To handle
 737          * this case,
 738          * server emulates the instruction at PC and finds the base address of
 739          * the load/store
 740          * instruction and appends it in the description of the stop-info
 741          * packet. If watchpoint
 742          * is not set on this address by user then this do not stop.
 743         */
 744         if (m_watch_hit_addr != LLDB_INVALID_ADDRESS) {
 745           WatchpointSP wp_hit_sp =
 746               thread_sp->CalculateTarget()->GetWatchpointList().FindByAddress(
 747                   m_watch_hit_addr);
 748           if (!wp_hit_sp) {
 749             m_should_stop = false;
 750             wp_sp->IncrementFalseAlarmsAndReviseHitCount();
 751           }
 752         }
 753
 754         // TODO: This condition should be checked in the synchronous part of the
 755         // watchpoint code
 756         // (Watchpoint::ShouldStop), so that we avoid pulling an event even if
 757         // the watchpoint fails
 758         // the ignore count condition. It is moved here temporarily, because for
 759         // archs with
 760         // watchpoint_exceptions_received=before, the code in the previous lines
 761         // takes care of moving
 762         // the inferior to next PC. We have to check the ignore count condition
 763         // after this is done,
 764         // otherwise we will hit same watchpoint multiple times until we pass
 765         // ignore condition, but we
 766         // won't actually be ignoring them.
 767         if (wp_sp->GetHitCount() <= wp_sp->GetIgnoreCount())
 768           m_should_stop = false;
 769
 770         Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
 771
 772         if (m_should_stop && wp_sp->GetConditionText() != nullptr) {
 773           // We need to make sure the user sees any parse errors in their
 774           // condition, so we'll hook the constructor errors up to the
 775           // debugger's Async I/O.
 776           ExpressionResults result_code;
 777           EvaluateExpressionOptions expr_options;
 778           expr_options.SetUnwindOnError(true);
 779           expr_options.SetIgnoreBreakpoints(true);
 780           ValueObjectSP result_value_sp;
 781           Error error;
 782           result_code = UserExpression::Evaluate(
 783               exe_ctx, expr_options, wp_sp->GetConditionText(),
 784               llvm::StringRef(), result_value_sp, error);
 785
 786           if (result_code == eExpressionCompleted) {
 787             if (result_value_sp) {
 788               Scalar scalar_value;
 789               if (result_value_sp->ResolveValue(scalar_value)) {
 790                 if (scalar_value.ULongLong(1) == 0) {
 791                   // We have been vetoed.  This takes precedence over querying
 792                   // the watchpoint whether it should stop (aka ignore count and
 793                   // friends).  See also StopInfoWatchpoint::ShouldStop() as
 794                   // well as Process::ProcessEventData::DoOnRemoval().
 795                   m_should_stop = false;
 796                 } else
 797                   m_should_stop = true;
 798                 if (log)
 799                   log->Printf(
 800                       "Condition successfully evaluated, result is %s.\n",
 801                       m_should_stop ? "true" : "false");
 802               } else {
 803                 m_should_stop = true;
 804                 if (log)
 805                   log->Printf(
 806                       "Failed to get an integer result from the expression.");
 807               }
 808             }
 809           } else {
 810             StreamSP error_sp = debugger.GetAsyncErrorStream();
 811             error_sp->Printf(
 812                 "Stopped due to an error evaluating condition of watchpoint ");
 813             wp_sp->GetDescription(error_sp.get(), eDescriptionLevelBrief);
 814             error_sp->Printf(": \"%s\"", wp_sp->GetConditionText());
 815             error_sp->EOL();
 816             const char *err_str = error.AsCString("<Unknown Error>");
 817             if (log)
 818               log->Printf("Error evaluating condition: \"%s\"\n", err_str);
 819
 820             error_sp->PutCString(err_str);
 821             error_sp->EOL();
 822             error_sp->Flush();
 823             // If the condition fails to be parsed or run, we should stop.
 824             m_should_stop = true;
 825           }
 826         }
 827
 828         // If the condition says to stop, we run the callback to further decide
 829         // whether to stop.
 830         if (m_should_stop) {
 831             // FIXME: For now the callbacks have to run in async mode - the
 832             // first time we restart we need
 833             // to get out of there.  So set it here.
 834             // When we figure out how to nest watchpoint hits then this will
 835             // change.
 836
 837           bool old_async = debugger.GetAsyncExecution();
 838           debugger.SetAsyncExecution(true);
 839
 840           StoppointCallbackContext context(event_ptr, exe_ctx, false);
 841           bool stop_requested = wp_sp->InvokeCallback(&context);
 842
 843           debugger.SetAsyncExecution(old_async);
 844
 845           // Also make sure that the callback hasn't continued the target.
 846           // If it did, when we'll set m_should_stop to false and get out of
 847           // here.
 848           if (HasTargetRunSinceMe())
 849             m_should_stop = false;
 850
 851           if (m_should_stop && !stop_requested) {
 852             // We have been vetoed by the callback mechanism.
 853             m_should_stop = false;
 854           }
 855         }
 856         // Finally, if we are going to stop, print out the new & old values:
 857         if (m_should_stop) {
 858           wp_sp->CaptureWatchedValue(exe_ctx);
 859
 860           Debugger &debugger = exe_ctx.GetTargetRef().GetDebugger();
 861           StreamSP output_sp = debugger.GetAsyncOutputStream();
 862           wp_sp->DumpSnapshots(output_sp.get());
 863           output_sp->EOL();
 864           output_sp->Flush();
 865         }
 866
 867       } else {
 868         Log *log_process(
 869             lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 870
 871         if (log_process)
 872           log_process->Printf(
 873               "Process::%s could not find watchpoint id: %" PRId64 "...",
 874               __FUNCTION__, m_value);
 875       }
 876       if (log)
 877         log->Printf("Process::%s returning from action with m_should_stop: %d.",
 878                     __FUNCTION__, m_should_stop);
 879
 880       m_should_stop_is_valid = true;
 881     }
 882   }
 883
 884 private:
 885   bool m_should_stop;
 886   bool m_should_stop_is_valid;
 887   lldb::addr_t m_watch_hit_addr;
 888 };
 889
 890 //----------------------------------------------------------------------
 891 // StopInfoUnixSignal
 892 //----------------------------------------------------------------------
 893
 894 class StopInfoUnixSignal : public StopInfo {
 895 public:
 896   StopInfoUnixSignal(Thread &thread, int signo, const char *description)
 897       : StopInfo(thread, signo) {
 898     SetDescription(description);
 899   }
 900
 901   ~StopInfoUnixSignal() override = default;
 902
 903   StopReason GetStopReason() const override { return eStopReasonSignal; }
 904
 905   bool ShouldStopSynchronous(Event *event_ptr) override {
 906     ThreadSP thread_sp(m_thread_wp.lock());
 907     if (thread_sp)
 908       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
 909     return false;
 910   }
 911
 912   bool ShouldStop(Event *event_ptr) override {
 913     ThreadSP thread_sp(m_thread_wp.lock());
 914     if (thread_sp)
 915       return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
 916     return false;
 917   }
 918
 919   // If should stop returns false, check if we should notify of this event
 920   bool DoShouldNotify(Event *event_ptr) override {
 921     ThreadSP thread_sp(m_thread_wp.lock());
 922     if (thread_sp) {
 923       bool should_notify =
 924           thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
 925       if (should_notify) {
 926         StreamString strm;
 927         strm.Printf(
 928             "thread %d received signal: %s", thread_sp->GetIndexID(),
 929             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
 930                 m_value));
 931         Process::ProcessEventData::AddRestartedReason(event_ptr,
 932                                                       strm.GetData());
 933       }
 934       return should_notify;
 935     }
 936     return true;
 937   }
 938
 939   void WillResume(lldb::StateType resume_state) override {
 940     ThreadSP thread_sp(m_thread_wp.lock());
 941     if (thread_sp) {
 942       if (!thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(
 943               m_value))
 944         thread_sp->SetResumeSignal(m_value);
 945     }
 946   }
 947
 948   const char *GetDescription() override {
 949     if (m_description.empty()) {
 950       ThreadSP thread_sp(m_thread_wp.lock());
 951       if (thread_sp) {
 952         StreamString strm;
 953         const char *signal_name =
 954             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
 955                 m_value);
 956         if (signal_name)
 957           strm.Printf("signal %s", signal_name);
 958         else
 959           strm.Printf("signal %" PRIi64, m_value);
 960         m_description = strm.GetString();
 961       }
 962     }
 963     return m_description.c_str();
 964   }
 965 };
 966
 967 //----------------------------------------------------------------------
 968 // StopInfoTrace
 969 //----------------------------------------------------------------------
 970
 971 class StopInfoTrace : public StopInfo {
 972 public:
 973   StopInfoTrace(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {}
 974
 975   ~StopInfoTrace() override = default;
 976
 977   StopReason GetStopReason() const override { return eStopReasonTrace; }
 978
 979   const char *GetDescription() override {
 980     if (m_description.empty())
 981       return "trace";
 982     else
 983       return m_description.c_str();
 984   }
 985 };
 986
 987 //----------------------------------------------------------------------
 988 // StopInfoException
 989 //----------------------------------------------------------------------
 990
 991 class StopInfoException : public StopInfo {
 992 public:
 993   StopInfoException(Thread &thread, const char *description)
 994       : StopInfo(thread, LLDB_INVALID_UID) {
 995     if (description)
 996       SetDescription(description);
 997   }
 998
 999   ~StopInfoException() override = default;
1000
1001   StopReason GetStopReason() const override { return eStopReasonException; }
1002
1003   const char *GetDescription() override {
1004     if (m_description.empty())
1005       return "exception";
1006     else
1007       return m_description.c_str();
1008   }
1009 };
1010
1011 //----------------------------------------------------------------------
1012 // StopInfoThreadPlan
1013 //----------------------------------------------------------------------
1014
1015 class StopInfoThreadPlan : public StopInfo {
1016 public:
1017   StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
1018                      ExpressionVariableSP &expression_variable_sp)
1019       : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
1020         m_return_valobj_sp(return_valobj_sp),
1021         m_expression_variable_sp(expression_variable_sp) {}
1022
1023   ~StopInfoThreadPlan() override = default;
1024
1025   StopReason GetStopReason() const override { return eStopReasonPlanComplete; }
1026
1027   const char *GetDescription() override {
1028     if (m_description.empty()) {
1029       StreamString strm;
1030       m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
1031       m_description = strm.GetString();
1032     }
1033     return m_description.c_str();
1034   }
1035
1036   ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; }
1037
1038   ExpressionVariableSP GetExpressionVariable() {
1039     return m_expression_variable_sp;
1040   }
1041
1042 protected:
1043   bool ShouldStop(Event *event_ptr) override {
1044     if (m_plan_sp)
1045       return m_plan_sp->ShouldStop(event_ptr);
1046     else
1047       return StopInfo::ShouldStop(event_ptr);
1048   }
1049
1050 private:
1051   ThreadPlanSP m_plan_sp;
1052   ValueObjectSP m_return_valobj_sp;
1053   ExpressionVariableSP m_expression_variable_sp;
1054 };
1055
1056 class StopInfoExec : public StopInfo {
1057 public:
1058   StopInfoExec(Thread &thread)
1059       : StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false) {}
1060
1061   ~StopInfoExec() override = default;
1062
1063   StopReason GetStopReason() const override { return eStopReasonExec; }
1064
1065   const char *GetDescription() override { return "exec"; }
1066
1067 protected:
1068   void PerformAction(Event *event_ptr) override {
1069     // Only perform the action once
1070     if (m_performed_action)
1071       return;
1072     m_performed_action = true;
1073     ThreadSP thread_sp(m_thread_wp.lock());
1074     if (thread_sp)
1075       thread_sp->GetProcess()->DidExec();
1076   }
1077
1078   bool m_performed_action;
1079 };
1080
1081 } // namespace lldb_private
1082
1083 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
1084                                                           break_id_t break_id) {
1085   return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
1086 }
1087
1088 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
1089                                                           break_id_t break_id,
1090                                                           bool should_stop) {
1091   return StopInfoSP(new StopInfoBreakpoint(thread, break_id, should_stop));
1092 }
1093
1094 StopInfoSP
1095 StopInfo::CreateStopReasonWithWatchpointID(Thread &thread, break_id_t watch_id,
1096                                            lldb::addr_t watch_hit_addr) {
1097   return StopInfoSP(new StopInfoWatchpoint(thread, watch_id, watch_hit_addr));
1098 }
1099
1100 StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
1101                                                 const char *description) {
1102   return StopInfoSP(new StopInfoUnixSignal(thread, signo, description));
1103 }
1104
1105 StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) {
1106   return StopInfoSP(new StopInfoTrace(thread));
1107 }
1108
1109 StopInfoSP StopInfo::CreateStopReasonWithPlan(
1110     ThreadPlanSP &plan_sp, ValueObjectSP return_valobj_sp,
1111     ExpressionVariableSP expression_variable_sp) {
1112   return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
1113                                            expression_variable_sp));
1114 }
1115
1116 StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread,
1117                                                    const char *description) {
1118   return StopInfoSP(new StopInfoException(thread, description));
1119 }
1120
1121 StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) {
1122   return StopInfoSP(new StopInfoExec(thread));
1123 }
1124
1125 ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) {
1126   if (stop_info_sp &&
1127       stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1128     StopInfoThreadPlan *plan_stop_info =
1129         static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1130     return plan_stop_info->GetReturnValueObject();
1131   } else
1132     return ValueObjectSP();
1133 }
1134
1135 ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) {
1136   if (stop_info_sp &&
1137       stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
1138     StopInfoThreadPlan *plan_stop_info =
1139         static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
1140     return plan_stop_info->GetExpressionVariable();
1141   } else
1142     return ExpressionVariableSP();
1143 }
1144
1145 lldb::ValueObjectSP
1146 StopInfo::GetCrashingDereference(StopInfoSP &stop_info_sp,
1147                                  lldb::addr_t *crashing_address) {
1148   if (!stop_info_sp) {
1149     return ValueObjectSP();
1150   }
1151
1152   const char *description = stop_info_sp->GetDescription();
1153   if (!description) {
1154     return ValueObjectSP();
1155   }
1156
1157   ThreadSP thread_sp = stop_info_sp->GetThread();
1158   if (!thread_sp) {
1159     return ValueObjectSP();
1160   }
1161
1162   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
1163
1164   if (!frame_sp) {
1165     return ValueObjectSP();
1166   }
1167
1168   const char address_string[] = "address=";
1169
1170   const char *address_loc = strstr(description, address_string);
1171   if (!address_loc) {
1172     return ValueObjectSP();
1173   }
1174
1175   address_loc += (sizeof(address_string) - 1);
1176
1177   uint64_t address = strtoull(address_loc, 0, 0);
1178   if (crashing_address) {
1179     *crashing_address = address;
1180   }
1181
1182   return frame_sp->GuessValueForAddress(address);
1183 }