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