LLDB  mainline
BreakpointResolver.h
Go to the documentation of this file.
1 //===-- BreakpointResolver.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_BREAKPOINT_BREAKPOINTRESOLVER_H
10 #define LLDB_BREAKPOINT_BREAKPOINTRESOLVER_H
11 
13 #include "lldb/Core/Address.h"
14 #include "lldb/Core/SearchFilter.h"
16 #include "lldb/Utility/FileSpec.h"
18 #include "lldb/lldb-private.h"
19 
20 namespace lldb_private {
21 
22 /// \class BreakpointResolver BreakpointResolver.h
23 /// "lldb/Breakpoint/BreakpointResolver.h" This class works with SearchFilter
24 /// to resolve logical breakpoints to their of concrete breakpoint locations.
25 
26 /// General Outline:
27 /// The BreakpointResolver is a Searcher. In that protocol, the SearchFilter
28 /// asks the question "At what depth of the symbol context descent do you want
29 /// your callback to get called?" of the filter. The resolver answers this
30 /// question (in the GetDepth method) and provides the resolution callback.
31 /// Each Breakpoint has a BreakpointResolver, and it calls either
32 /// ResolveBreakpoint or ResolveBreakpointInModules to tell it to look for new
33 /// breakpoint locations.
34 
35 class BreakpointResolver : public Searcher {
36  friend class Breakpoint;
37 
38 public:
39  /// The breakpoint resolver need to have a breakpoint for "ResolveBreakpoint
40  /// to make sense. It can be constructed without a breakpoint, but you have
41  /// to call SetBreakpoint before ResolveBreakpoint.
42  ///
43  /// \param[in] bkpt
44  /// The breakpoint that owns this resolver.
45  /// \param[in] resolverType
46  /// The concrete breakpoint resolver type for this breakpoint.
47  BreakpointResolver(const lldb::BreakpointSP &bkpt,
48  unsigned char resolverType,
49  lldb::addr_t offset = 0);
50 
51  /// The Destructor is virtual, all significant breakpoint resolvers derive
52  /// from this class.
53  ~BreakpointResolver() override;
54 
55  /// This sets the breakpoint for this resolver.
56  ///
57  /// \param[in] bkpt
58  /// The breakpoint that owns this resolver.
59  void SetBreakpoint(const lldb::BreakpointSP &bkpt);
60 
61  /// This gets the breakpoint for this resolver.
62  lldb::BreakpointSP GetBreakpoint() const {
63  auto breakpoint_sp = m_breakpoint.expired() ? lldb::BreakpointSP() :
64  m_breakpoint.lock();
65  assert(breakpoint_sp);
66  return breakpoint_sp;
67  }
68 
69  /// This updates the offset for this breakpoint. All the locations
70  /// currently set for this breakpoint will have their offset adjusted when
71  /// this is called.
72  ///
73  /// \param[in] offset
74  /// The offset to add to all locations.
75  void SetOffset(lldb::addr_t offset);
76 
77  lldb::addr_t GetOffset() const { return m_offset; }
78 
79  /// In response to this method the resolver scans all the modules in the
80  /// breakpoint's target, and adds any new locations it finds.
81  ///
82  /// \param[in] filter
83  /// The filter that will manage the search for this resolver.
84  virtual void ResolveBreakpoint(SearchFilter &filter);
85 
86  /// In response to this method the resolver scans the modules in the module
87  /// list \a modules, and adds any new locations it finds.
88  ///
89  /// \param[in] filter
90  /// The filter that will manage the search for this resolver.
91  virtual void ResolveBreakpointInModules(SearchFilter &filter,
92  ModuleList &modules);
93 
94  /// Prints a canonical description for the breakpoint to the stream \a s.
95  ///
96  /// \param[in] s
97  /// Stream to which the output is copied.
98  void GetDescription(Stream *s) override = 0;
99 
100  /// Standard "Dump" method. At present it does nothing.
101  virtual void Dump(Stream *s) const = 0;
102 
103  /// This section handles serializing and deserializing from StructuredData
104  /// objects.
105 
106  static lldb::BreakpointResolverSP
108  Status &error);
109 
111  return StructuredData::ObjectSP();
112  }
113 
114  static const char *GetSerializationKey() { return "BKPTResolver"; }
115 
116  static const char *GetSerializationSubclassKey() { return "Type"; }
117 
118  static const char *GetSerializationSubclassOptionsKey() { return "Options"; }
119 
122 
123  /// An enumeration for keeping track of the concrete subclass that is
124  /// actually instantiated. Values of this enumeration are kept in the
125  /// BreakpointResolver's SubclassID field. They are used for concrete type
126  /// identification.
127  enum ResolverTy {
128  FileLineResolver = 0, // This is an instance of BreakpointResolverFileLine
129  AddressResolver, // This is an instance of BreakpointResolverAddress
130  NameResolver, // This is an instance of BreakpointResolverName
136  };
137 
138  // Translate the Ty to name for serialization, the "+2" is one for size vrs.
139  // index, and one for UnknownResolver.
140  static const char *g_ty_to_name[LastKnownResolverType + 2];
141 
142  /// getResolverID - Return an ID for the concrete type of this object. This
143  /// is used to implement the LLVM classof checks. This should not be used
144  /// for any other purpose, as the values may change as LLDB evolves.
145  unsigned getResolverID() const { return SubclassID; }
146 
148  if (SubclassID > ResolverTy::LastKnownResolverType)
149  return ResolverTy::UnknownResolver;
150  else
151  return (enum ResolverTy)SubclassID;
152  }
153 
154  const char *GetResolverName() { return ResolverTyToName(GetResolverTy()); }
155 
156  static const char *ResolverTyToName(enum ResolverTy);
157 
158  static ResolverTy NameToResolverTy(llvm::StringRef name);
159 
160  virtual lldb::BreakpointResolverSP
161  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) = 0;
162 
163 protected:
164  // Used for serializing resolver options:
165  // The options in this enum and the strings in the g_option_names must be
166  // kept in sync.
167  enum class OptionNames : uint32_t {
168  AddressOffset = 0,
169  ExactMatch,
170  FileName,
171  Inlines,
172  LanguageName,
173  LineNumber,
174  Column,
175  ModuleName,
177  Offset,
179  RegexString,
180  ScriptArgs,
181  SectionName,
182  SearchDepth,
183  SkipPrologue,
186  };
187  static const char
189 
190  virtual void NotifyBreakpointSet() {};
191 
192 public:
193  static const char *GetKey(OptionNames enum_value) {
194  return g_option_names[static_cast<uint32_t>(enum_value)];
195  }
196 
197 protected:
198  /// Takes a symbol context list of matches which supposedly represent the
199  /// same file and line number in a CU, and find the nearest actual line
200  /// number that matches, and then filter down the matching addresses to
201  /// unique entries, and skip the prologue if asked to do so, and then set
202  /// breakpoint locations in this breakpoint for all the resultant addresses.
203  /// When \p column is nonzero the \p line and \p column args are used to
204  /// filter the results to find the first breakpoint >= (line, column).
205  void SetSCMatchesByLine(SearchFilter &filter, SymbolContextList &sc_list,
206  bool skip_prologue, llvm::StringRef log_ident,
207  uint32_t line = 0, uint32_t column = 0);
209  const char *) = delete;
210 
211  lldb::BreakpointLocationSP AddLocation(Address loc_addr,
212  bool *new_location = nullptr);
213 
214 private:
215  /// Helper for \p SetSCMatchesByLine.
216  void AddLocation(SearchFilter &filter, const SymbolContext &sc,
217  bool skip_prologue, llvm::StringRef log_ident);
218 
219  lldb::BreakpointWP m_breakpoint; // This is the breakpoint we add locations to.
220  lldb::addr_t m_offset; // A random offset the user asked us to add to any
221  // breakpoints we set.
222 
223  // Subclass identifier (for llvm isa/dyn_cast)
224  const unsigned char SubclassID;
225  BreakpointResolver(const BreakpointResolver &) = delete;
226  const BreakpointResolver &operator=(const BreakpointResolver &) = delete;
227 };
228 
229 } // namespace lldb_private
230 
231 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVER_H
static lldb::BreakpointResolverSP CreateFromStructuredData(const StructuredData::Dictionary &resolver_dict, Status &error)
This section handles serializing and deserializing from StructuredData objects.
static const char * GetSerializationSubclassOptionsKey()
unsigned getResolverID() const
getResolverID - Return an ID for the concrete type of this object.
Defines a list of symbol context objects.
A class that represents a running process on the host machine.
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
static const char * GetSerializationSubclassKey()
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:78
virtual void ResolveBreakpointInModules(SearchFilter &filter, ModuleList &modules)
In response to this method the resolver scans the modules in the module list modules, and adds any new locations it finds.
virtual StructuredData::ObjectSP SerializeToStructuredData()
void SetBreakpoint(const lldb::BreakpointSP &bkpt)
This sets the breakpoint for this resolver.
lldb::BreakpointLocationSP AddLocation(Address loc_addr, bool *new_location=nullptr)
std::shared_ptr< Dictionary > DictionarySP
virtual void ResolveBreakpoint(SearchFilter &filter)
In response to this method the resolver scans all the modules in the breakpoint&#39;s target...
static const char * GetSerializationKey()
static llvm::raw_ostream & error(Stream &strm)
void SetSCMatchesByLine(SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue, llvm::StringRef log_ident, uint32_t line=0, uint32_t column=0)
Takes a symbol context list of matches which supposedly represent the same file and line number in a ...
static const char * g_ty_to_name[LastKnownResolverType+2]
A collection class for Module objects.
Definition: ModuleList.h:71
General Outline: The BreakpointResolver is a Searcher.
static const char * g_option_names[static_cast< uint32_t >(OptionNames::LastOptionName)]
General Outline: Provides the callback and search depth for the SearchFilter search.
Definition: SearchFilter.h:83
General Outline: Provides the callback and search depth for the SearchFilter search.
Definition: SearchFilter.h:42
~BreakpointResolver() override
The Destructor is virtual, all significant breakpoint resolvers derive from this class.
BreakpointResolver(const lldb::BreakpointSP &bkpt, unsigned char resolverType, lldb::addr_t offset=0)
The breakpoint resolver need to have a breakpoint for "ResolveBreakpoint to make sense.
A section + offset based address class.
Definition: Address.h:59
static ResolverTy NameToResolverTy(llvm::StringRef name)
void GetDescription(Stream *s) override=0
Prints a canonical description for the breakpoint to the stream s.
virtual lldb::BreakpointResolverSP CopyForBreakpoint(lldb::BreakpointSP &breakpoint)=0
virtual void Dump(Stream *s) const =0
Standard "Dump" method. At present it does nothing.
static const char * ResolverTyToName(enum ResolverTy)
uint64_t addr_t
Definition: lldb-types.h:83
void SetOffset(lldb::addr_t offset)
This updates the offset for this breakpoint.
This class finds address for source file and line.
ResolverTy
An enumeration for keeping track of the concrete subclass that is actually instantiated.
std::shared_ptr< Object > ObjectSP
lldb::BreakpointSP GetBreakpoint() const
This gets the breakpoint for this resolver.
const BreakpointResolver & operator=(const BreakpointResolver &)=delete
StructuredData::DictionarySP WrapOptionsDict(StructuredData::DictionarySP options_dict_sp)
static const char * GetKey(OptionNames enum_value)
An error handling class.
Definition: Status.h:44