1//===-- ThreadPlanBase.cpp ------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "lldb/Target/ThreadPlanBase.h"
10
11//
12#include "lldb/Breakpoint/Breakpoint.h"
13#include "lldb/Breakpoint/BreakpointLocation.h"
14#include "lldb/Breakpoint/BreakpointSite.h"
15#include "lldb/Breakpoint/StoppointCallbackContext.h"
16#include "lldb/Target/Process.h"
17#include "lldb/Target/RegisterContext.h"
18#include "lldb/Target/StopInfo.h"
19#include "lldb/Utility/LLDBLog.h"
20#include "lldb/Utility/Log.h"
21#include "lldb/Utility/Stream.h"
22
23using namespace lldb;
24using namespace lldb_private;
25
26// ThreadPlanBase: This one always stops, and never has anything particular to
27// do.
28// FIXME: The "signal handling" policies should probably go here.
29
30ThreadPlanBase::ThreadPlanBase(Thread &thread)
31    : ThreadPlan(ThreadPlan::eKindBase, "base plan", thread, eVoteYes,
32                 eVoteNoOpinion) {
33// Set the tracer to a default tracer.
34// FIXME: need to add a thread settings variable to pix various tracers...
35#define THREAD_PLAN_USE_ASSEMBLY_TRACER 1
36
37#ifdef THREAD_PLAN_USE_ASSEMBLY_TRACER
38  ThreadPlanTracerSP new_tracer_sp(new ThreadPlanAssemblyTracer(thread));
39#else
40  ThreadPlanTracerSP new_tracer_sp(new ThreadPlanTracer(m_thread));
41#endif
42  new_tracer_sp->EnableTracing(thread.GetTraceEnabledState());
43  SetThreadPlanTracer(new_tracer_sp);
44  SetIsControllingPlan(true);
45}
46
47ThreadPlanBase::~ThreadPlanBase() = default;
48
49void ThreadPlanBase::GetDescription(Stream *s, lldb::DescriptionLevel level) {
50  s->Printf("Base thread plan.");
51}
52
53bool ThreadPlanBase::ValidatePlan(Stream *error) { return true; }
54
55bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) {
56  // The base plan should defer to its tracer, since by default it always
57  // handles the stop.
58  return !TracerExplainsStop();
59}
60
61Vote ThreadPlanBase::ShouldReportStop(Event *event_ptr) {
62  StopInfoSP stop_info_sp = GetThread().GetStopInfo();
63  if (stop_info_sp) {
64    bool should_notify = stop_info_sp->ShouldNotify(event_ptr);
65    if (should_notify)
66      return eVoteYes;
67    else
68      return eVoteNoOpinion;
69  } else
70    return eVoteNoOpinion;
71}
72
73bool ThreadPlanBase::ShouldStop(Event *event_ptr) {
74  m_report_stop_vote = eVoteYes;
75  m_report_run_vote = eVoteYes;
76
77  Log *log = GetLog(LLDBLog::Step);
78
79  StopInfoSP stop_info_sp = GetPrivateStopInfo();
80  if (stop_info_sp) {
81    StopReason reason = stop_info_sp->GetStopReason();
82    switch (reason) {
83    case eStopReasonInvalid:
84    case eStopReasonNone:
85      // This
86      m_report_run_vote = eVoteNoOpinion;
87      m_report_stop_vote = eVoteNo;
88      return false;
89
90    case eStopReasonBreakpoint:
91    case eStopReasonWatchpoint:
92      if (stop_info_sp->ShouldStopSynchronous(event_ptr)) {
93        // If we are going to stop for a breakpoint, then unship the other
94        // plans at this point.  Don't force the discard, however, so
95        // Controlling plans can stay in place if they want to.
96        LLDB_LOGF(
97            log,
98            "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
99            " (breakpoint hit.)",
100            m_tid);
101        GetThread().DiscardThreadPlans(false);
102        return true;
103      }
104      // If we aren't going to stop at this breakpoint, and it is internal,
105      // don't report this stop or the subsequent running event. Otherwise we
106      // will post the stopped & running, but the stopped event will get marked
107      // with "restarted" so the UI will know to wait and expect the consequent
108      // "running".
109      if (stop_info_sp->ShouldNotify(event_ptr)) {
110        m_report_stop_vote = eVoteYes;
111        m_report_run_vote = eVoteYes;
112      } else {
113        m_report_stop_vote = eVoteNo;
114        m_report_run_vote = eVoteNo;
115      }
116      return false;
117
118      // TODO: the break below was missing, was this intentional??? If so
119      // please mention it
120      break;
121
122    case eStopReasonException:
123      // If we crashed, discard thread plans and stop.  Don't force the
124      // discard, however, since on rerun the target may clean up this
125      // exception and continue normally from there.
126      LLDB_LOGF(
127          log,
128          "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
129          " (exception: %s)",
130          m_tid, stop_info_sp->GetDescription());
131      GetThread().DiscardThreadPlans(false);
132      return true;
133
134    case eStopReasonExec:
135      // If we crashed, discard thread plans and stop.  Don't force the
136      // discard, however, since on rerun the target may clean up this
137      // exception and continue normally from there.
138      LLDB_LOGF(
139          log,
140          "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
141          " (exec.)",
142          m_tid);
143      GetThread().DiscardThreadPlans(false);
144      return true;
145
146    case eStopReasonThreadExiting:
147    case eStopReasonSignal:
148      if (stop_info_sp->ShouldStop(event_ptr)) {
149        LLDB_LOGF(
150            log,
151            "Base plan discarding thread plans for thread tid = 0x%4.4" PRIx64
152            " (signal: %s)",
153            m_tid, stop_info_sp->GetDescription());
154        GetThread().DiscardThreadPlans(false);
155        return true;
156      } else {
157        // We're not going to stop, but while we are here, let's figure out
158        // whether to report this.
159        if (stop_info_sp->ShouldNotify(event_ptr))
160          m_report_stop_vote = eVoteYes;
161        else
162          m_report_stop_vote = eVoteNo;
163      }
164      return false;
165
166    default:
167      return true;
168    }
169
170  } else {
171    m_report_run_vote = eVoteNoOpinion;
172    m_report_stop_vote = eVoteNo;
173  }
174
175  // If there's no explicit reason to stop, then we will continue.
176  return false;
177}
178
179bool ThreadPlanBase::StopOthers() { return false; }
180
181StateType ThreadPlanBase::GetPlanRunState() { return eStateRunning; }
182
183bool ThreadPlanBase::WillStop() { return true; }
184
185bool ThreadPlanBase::DoWillResume(lldb::StateType resume_state,
186                                  bool current_plan) {
187  // Reset these to the default values so we don't set them wrong, then not get
188  // asked for a while, then return the wrong answer.
189  m_report_run_vote = eVoteNoOpinion;
190  m_report_stop_vote = eVoteNo;
191  return true;
192}
193
194// The base plan is never done.
195bool ThreadPlanBase::MischiefManaged() {
196  // The base plan is never done.
197  return false;
198}
199