Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Target/StopInfo.h
Line
Count
Source (jump to first uncovered line)
1
//===-- StopInfo.h ----------------------------------------------*- C++ -*-===//
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
#ifndef LLDB_TARGET_STOPINFO_H
10
#define LLDB_TARGET_STOPINFO_H
11
12
#include <string>
13
14
#include "lldb/Target/Process.h"
15
#include "lldb/Utility/StructuredData.h"
16
#include "lldb/lldb-public.h"
17
18
namespace lldb_private {
19
20
class StopInfo {
21
  friend class Process::ProcessEventData;
22
  friend class ThreadPlanBase;
23
24
public:
25
  // Constructors and Destructors
26
  StopInfo(Thread &thread, uint64_t value);
27
28
31.6k
  virtual ~StopInfo() = default;
29
30
  bool IsValid() const;
31
32
3
  void SetThread(const lldb::ThreadSP &thread_sp) { m_thread_wp = thread_sp; }
33
34
1.46k
  lldb::ThreadSP GetThread() const { return m_thread_wp.lock(); }
35
36
  // The value of the StopInfo depends on the StopReason.
37
  //
38
  // StopReason Meaning
39
  // ------------------------------------------------
40
  // eStopReasonBreakpoint       BreakpointSiteID
41
  // eStopReasonSignal           Signal number
42
  // eStopReasonWatchpoint       WatchpointLocationID
43
  // eStopReasonPlanComplete     No significance
44
45
6.46k
  uint64_t GetValue() const { return m_value; }
46
47
  virtual lldb::StopReason GetStopReason() const = 0;
48
49
  // ShouldStopSynchronous will get called before any thread plans are
50
  // consulted, and if it says we should resume the target, then we will just
51
  // immediately resume.  This should not run any code in or resume the target.
52
53
5.17k
  virtual bool ShouldStopSynchronous(Event *event_ptr) { return true; }
54
55
2.59k
  void OverrideShouldNotify(bool override_value) {
56
2.59k
    m_override_should_notify = override_value ? 
eLazyBoolYes15
:
eLazyBoolNo2.58k
;
57
2.59k
  }
58
59
  // If should stop returns false, check if we should notify of this event
60
2.69k
  virtual bool ShouldNotify(Event *event_ptr) {
61
2.69k
    if (m_override_should_notify == eLazyBoolCalculate)
62
2.69k
      return DoShouldNotify(event_ptr);
63
0
    else
64
0
      return m_override_should_notify == eLazyBoolYes;
65
2.69k
  }
66
67
10.2k
  virtual void WillResume(lldb::StateType resume_state) {
68
    // By default, don't do anything
69
10.2k
  }
70
71
0
  virtual const char *GetDescription() { return m_description.c_str(); }
72
73
7.54k
  virtual void SetDescription(const char *desc_cstr) {
74
7.54k
    if (desc_cstr && 
desc_cstr[0]77
)
75
7
      m_description.assign(desc_cstr);
76
7.53k
    else
77
7.53k
      m_description.clear();
78
7.54k
  }
79
80
1
  virtual bool IsValidForOperatingSystemThread(Thread &thread) { return true; }
81
82
  // Sometimes the thread plan logic will know that it wants a given stop to
83
  // stop or not, regardless of what the ordinary logic for that StopInfo would
84
  // dictate.  The main example of this is the ThreadPlanCallFunction, which
85
  // for instance knows - based on how that particular expression was executed
86
  // - whether it wants all breakpoints to auto-continue or not. Use
87
  // OverrideShouldStop on the StopInfo to implement this.
88
89
112
  void OverrideShouldStop(bool override_value) {
90
112
    m_override_should_stop = override_value ? 
eLazyBoolYes37
:
eLazyBoolNo75
;
91
112
  }
92
93
11.9k
  bool GetOverrideShouldStop() {
94
11.9k
    return m_override_should_stop != eLazyBoolCalculate;
95
11.9k
  }
96
97
10
  bool GetOverriddenShouldStopValue() {
98
10
    return m_override_should_stop == eLazyBoolYes;
99
10
  }
100
101
3
  StructuredData::ObjectSP GetExtendedInfo() { return m_extended_info; }
102
103
  static lldb::StopInfoSP
104
  CreateStopReasonWithBreakpointSiteID(Thread &thread,
105
                                       lldb::break_id_t break_id);
106
107
  // This creates a StopInfo for the thread where the should_stop is already
108
  // set, and won't be recalculated.
109
  static lldb::StopInfoSP CreateStopReasonWithBreakpointSiteID(
110
      Thread &thread, lldb::break_id_t break_id, bool should_stop);
111
112
  static lldb::StopInfoSP CreateStopReasonWithWatchpointID(
113
      Thread &thread, lldb::break_id_t watch_id,
114
      lldb::addr_t watch_hit_addr = LLDB_INVALID_ADDRESS);
115
116
  static lldb::StopInfoSP
117
  CreateStopReasonWithSignal(Thread &thread, int signo,
118
                             const char *description = nullptr);
119
120
  static lldb::StopInfoSP CreateStopReasonToTrace(Thread &thread);
121
122
  static lldb::StopInfoSP
123
  CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan,
124
                           lldb::ValueObjectSP return_valobj_sp,
125
                           lldb::ExpressionVariableSP expression_variable_sp);
126
127
  static lldb::StopInfoSP
128
  CreateStopReasonWithException(Thread &thread, const char *description);
129
130
  static lldb::StopInfoSP CreateStopReasonWithExec(Thread &thread);
131
132
  static lldb::StopInfoSP
133
  CreateStopReasonProcessorTrace(Thread &thread, const char *description);
134
135
  static lldb::StopInfoSP CreateStopReasonFork(Thread &thread,
136
                                               lldb::pid_t child_pid,
137
                                               lldb::tid_t child_tid);
138
139
  static lldb::StopInfoSP CreateStopReasonVFork(Thread &thread,
140
                                                lldb::pid_t child_pid,
141
                                                lldb::tid_t child_tid);
142
143
  static lldb::StopInfoSP CreateStopReasonVForkDone(Thread &thread);
144
145
  static lldb::ValueObjectSP
146
  GetReturnValueObject(lldb::StopInfoSP &stop_info_sp);
147
148
  static lldb::ExpressionVariableSP
149
  GetExpressionVariable(lldb::StopInfoSP &stop_info_sp);
150
151
  static lldb::ValueObjectSP
152
  GetCrashingDereference(lldb::StopInfoSP &stop_info_sp,
153
                         lldb::addr_t *crashing_address = nullptr);
154
155
protected:
156
  // Perform any action that is associated with this stop.  This is done as the
157
  // Event is removed from the event queue.  ProcessEventData::DoOnRemoval does
158
  // the job.
159
160
3.33k
  virtual void PerformAction(Event *event_ptr) {}
161
162
0
  virtual bool DoShouldNotify(Event *event_ptr) { return false; }
163
164
  // Stop the thread by default. Subclasses can override this to allow the
165
  // thread to continue if desired.  The ShouldStop method should not do
166
  // anything that might run code.  If you need to run code when deciding
167
  // whether to stop at this StopInfo, that must be done in the PerformAction.
168
  // The PerformAction will always get called before the ShouldStop.  This is
169
  // done by the ProcessEventData::DoOnRemoval, though the ThreadPlanBase needs
170
  // to consult this later on.
171
147
  virtual bool ShouldStop(Event *event_ptr) { return true; }
172
173
  // Classes that inherit from StackID can see and modify these
174
  lldb::ThreadWP m_thread_wp; // The thread corresponding to the stop reason.
175
  uint32_t m_stop_id;   // The process stop ID for which this stop info is valid
176
  uint32_t m_resume_id; // This is the resume ID when we made this stop ID.
177
  uint64_t m_value; // A generic value that can be used for things pertaining to
178
                    // this stop info
179
  std::string m_description; // A textual description describing this stop.
180
  LazyBool m_override_should_notify;
181
  LazyBool m_override_should_stop;
182
183
  StructuredData::ObjectSP
184
      m_extended_info; // The extended info for this stop info
185
186
  // This determines whether the target has run since this stop info. N.B.
187
  // running to evaluate a user expression does not count.
188
  bool HasTargetRunSinceMe();
189
190
  // MakeStopInfoValid is necessary to allow saved stop infos to resurrect
191
  // themselves as valid. It should only be used by
192
  // Thread::RestoreThreadStateFromCheckpoint and to make sure the one-step
193
  // needed for before-the-fact watchpoints does not prevent us from stopping
194
  void MakeStopInfoValid();
195
196
private:
197
  friend class Thread;
198
199
  StopInfo(const StopInfo &) = delete;
200
  const StopInfo &operator=(const StopInfo &) = delete;
201
};
202
203
} // namespace lldb_private
204
205
#endif // LLDB_TARGET_STOPINFO_H