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