LLDB  mainline
BreakpointResolverFileLine.cpp
Go to the documentation of this file.
1 //===-- BreakpointResolverFileLine.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 
10 
12 #include "lldb/Core/Module.h"
14 #include "lldb/Symbol/Function.h"
15 #include "lldb/Target/Target.h"
16 #include "lldb/Utility/LLDBLog.h"
17 #include "lldb/Utility/Log.h"
19 
20 using namespace lldb;
21 using namespace lldb_private;
22 
23 // BreakpointResolverFileLine:
24 BreakpointResolverFileLine::BreakpointResolverFileLine(
25  const BreakpointSP &bkpt, lldb::addr_t offset, bool skip_prologue,
26  const SourceLocationSpec &location_spec,
27  llvm::Optional<llvm::StringRef> removed_prefix_opt)
29  m_location_spec(location_spec), m_skip_prologue(skip_prologue),
30  m_removed_prefix_opt(removed_prefix_opt) {}
31 
33  const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
34  Status &error) {
35  llvm::StringRef filename;
36  uint32_t line;
37  uint16_t column;
38  bool check_inlines;
39  bool skip_prologue;
40  bool exact_match;
41  bool success;
42 
43  lldb::addr_t offset = 0;
44 
45  success = options_dict.GetValueForKeyAsString(GetKey(OptionNames::FileName),
46  filename);
47  if (!success) {
48  error.SetErrorString("BRFL::CFSD: Couldn't find filename entry.");
49  return nullptr;
50  }
51 
52  success = options_dict.GetValueForKeyAsInteger(
54  if (!success) {
55  error.SetErrorString("BRFL::CFSD: Couldn't find line number entry.");
56  return nullptr;
57  }
58 
59  success =
60  options_dict.GetValueForKeyAsInteger(GetKey(OptionNames::Column), column);
61  if (!success) {
62  // Backwards compatibility.
63  column = 0;
64  }
65 
66  success = options_dict.GetValueForKeyAsBoolean(GetKey(OptionNames::Inlines),
67  check_inlines);
68  if (!success) {
69  error.SetErrorString("BRFL::CFSD: Couldn't find check inlines entry.");
70  return nullptr;
71  }
72 
73  success = options_dict.GetValueForKeyAsBoolean(
74  GetKey(OptionNames::SkipPrologue), skip_prologue);
75  if (!success) {
76  error.SetErrorString("BRFL::CFSD: Couldn't find skip prologue entry.");
77  return nullptr;
78  }
79 
80  success = options_dict.GetValueForKeyAsBoolean(
81  GetKey(OptionNames::ExactMatch), exact_match);
82  if (!success) {
83  error.SetErrorString("BRFL::CFSD: Couldn't find exact match entry.");
84  return nullptr;
85  }
86 
87  SourceLocationSpec location_spec(FileSpec(filename), line, column,
88  check_inlines, exact_match);
89  if (!location_spec)
90  return nullptr;
91 
92  return new BreakpointResolverFileLine(bkpt, offset, skip_prologue,
93  location_spec);
94 }
95 
98  StructuredData::DictionarySP options_dict_sp(
100 
101  options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
103  options_dict_sp->AddStringItem(GetKey(OptionNames::FileName),
105  options_dict_sp->AddIntegerItem(GetKey(OptionNames::LineNumber),
106  m_location_spec.GetLine().value_or(0));
107  options_dict_sp->AddIntegerItem(
110  options_dict_sp->AddBooleanItem(GetKey(OptionNames::Inlines),
112  options_dict_sp->AddBooleanItem(GetKey(OptionNames::ExactMatch),
114 
115  return WrapOptionsDict(options_dict_sp);
116 }
117 
118 // Filter the symbol context list to remove contexts where the line number was
119 // moved into a new function. We do this conservatively, so if e.g. we cannot
120 // resolve the function in the context (which can happen in case of line-table-
121 // only debug info), we leave the context as is. The trickiest part here is
122 // handling inlined functions -- in this case we need to make sure we look at
123 // the declaration line of the inlined function, NOT the function it was
124 // inlined into.
127  return; // Nothing to do. Contexts are precise.
128 
130  for(uint32_t i = 0; i < sc_list.GetSize(); ++i) {
131  SymbolContext sc;
132  sc_list.GetContextAtIndex(i, sc);
133  if (!sc.block)
134  continue;
135 
136  FileSpec file;
137  uint32_t line;
138  const Block *inline_block = sc.block->GetContainingInlinedBlock();
139  if (inline_block) {
140  const Declaration &inline_declaration = inline_block->GetInlinedFunctionInfo()->GetDeclaration();
141  if (!inline_declaration.IsValid())
142  continue;
143  file = inline_declaration.GetFile();
144  line = inline_declaration.GetLine();
145  } else if (sc.function)
146  sc.function->GetStartLineSourceInfo(file, line);
147  else
148  continue;
149 
150  if (file != sc.line_entry.file) {
151  LLDB_LOG(log, "unexpected symbol context file {0}", sc.line_entry.file);
152  continue;
153  }
154 
155  // Compare the requested line number with the line of the function
156  // declaration. In case of a function declared as:
157  //
158  // int
159  // foo()
160  // {
161  // ...
162  //
163  // the compiler will set the declaration line to the "foo" line, which is
164  // the reason why we have -1 here. This can fail in case of two inline
165  // functions defined back-to-back:
166  //
167  // inline int foo1() { ... }
168  // inline int foo2() { ... }
169  //
170  // but that's the best we can do for now.
171  // One complication, if the line number returned from GetStartLineSourceInfo
172  // is 0, then we can't do this calculation. That can happen if
173  // GetStartLineSourceInfo gets an error, or if the first line number in
174  // the function really is 0 - which happens for some languages.
175 
176  // But only do this calculation if the line number we found in the SC
177  // was different from the one requested in the source file. If we actually
178  // found an exact match it must be valid.
179 
181  continue;
182 
183  const int decl_line_is_too_late_fudge = 1;
184  if (line &&
185  m_location_spec.GetLine() < line - decl_line_is_too_late_fudge) {
186  LLDB_LOG(log, "removing symbol context at {0}:{1}", file, line);
187  sc_list.RemoveContextAtIndex(i);
188  --i;
189  }
190  }
191 }
192 
194  SymbolContextList &sc_list) {
195  Target &target = GetBreakpoint()->GetTarget();
196  if (!target.GetAutoSourceMapRelative())
197  return;
198 
200  const llvm::StringRef path_separator = llvm::sys::path::get_separator(
202  // Check if "b" is a suffix of "a".
203  // And return llvm::None if not or the new path
204  // of "a" after consuming "b" from the back.
205  auto check_suffix =
206  [path_separator](llvm::StringRef a, llvm::StringRef b,
207  bool case_sensitive) -> llvm::Optional<llvm::StringRef> {
208  if (case_sensitive ? a.consume_back(b) : a.consume_back_insensitive(b)) {
209  if (a.empty() || a.endswith(path_separator)) {
210  return a;
211  }
212  }
213  return llvm::None;
214  };
215 
216  FileSpec request_file = m_location_spec.GetFileSpec();
217 
218  // Only auto deduce source map if breakpoint is full path.
219  // Note: an existing source map reverse mapping (m_removed_prefix_opt has
220  // value) may make request_file relative.
221  if (!m_removed_prefix_opt.has_value() && request_file.IsRelative())
222  return;
223 
224  const bool case_sensitive = request_file.IsCaseSensitive();
225  for (uint32_t i = 0; i < sc_list.GetSize(); ++i) {
226  SymbolContext sc;
227  sc_list.GetContextAtIndex(i, sc);
228 
229  FileSpec sc_file = sc.line_entry.file;
230 
231  if (FileSpec::Equal(sc_file, request_file, /*full*/true))
232  continue;
233 
234  llvm::StringRef sc_file_dir = sc_file.GetDirectory().GetStringRef();
235  llvm::StringRef request_file_dir =
236  request_file.GetDirectory().GetStringRef();
237 
238  llvm::StringRef new_mapping_from;
239  llvm::SmallString<256> new_mapping_to;
240 
241  // Adding back any potentially reverse mapping stripped prefix.
242  // for new_mapping_to.
243  if (m_removed_prefix_opt.has_value())
244  llvm::sys::path::append(new_mapping_to, m_removed_prefix_opt.value());
245 
246  llvm::Optional<llvm::StringRef> new_mapping_from_opt =
247  check_suffix(sc_file_dir, request_file_dir, case_sensitive);
248  if (new_mapping_from_opt) {
249  new_mapping_from = new_mapping_from_opt.value();
250  if (new_mapping_to.empty())
251  new_mapping_to = ".";
252  } else {
253  llvm::Optional<llvm::StringRef> new_mapping_to_opt =
254  check_suffix(request_file_dir, sc_file_dir, case_sensitive);
255  if (new_mapping_to_opt) {
256  new_mapping_from = ".";
257  llvm::sys::path::append(new_mapping_to, new_mapping_to_opt.value());
258  }
259  }
260 
261  if (!new_mapping_from.empty() && !new_mapping_to.empty()) {
262  LLDB_LOG(log, "generating auto source map from {0} to {1}",
263  new_mapping_from, new_mapping_to);
264  if (target.GetSourcePathMap().AppendUnique(new_mapping_from,
265  new_mapping_to,
266  /*notify*/ true))
268  }
269  }
270 }
271 
273  SearchFilter &filter, SymbolContext &context, Address *addr) {
274  SymbolContextList sc_list;
275 
276  // There is a tricky bit here. You can have two compilation units that
277  // #include the same file, and in one of them the function at m_line_number
278  // is used (and so code and a line entry for it is generated) but in the
279  // other it isn't. If we considered the CU's independently, then in the
280  // second inclusion, we'd move the breakpoint to the next function that
281  // actually generated code in the header file. That would end up being
282  // confusing. So instead, we do the CU iterations by hand here, then scan
283  // through the complete list of matches, and figure out the closest line
284  // number match, and only set breakpoints on that match.
285 
286  // Note also that if file_spec only had a file name and not a directory,
287  // there may be many different file spec's in the resultant list. The
288  // closest line match for one will not be right for some totally different
289  // file. So we go through the match list and pull out the sets that have the
290  // same file spec in their line_entry and treat each set separately.
291 
292  const uint32_t line = m_location_spec.GetLine().value_or(0);
293  const llvm::Optional<uint16_t> column = m_location_spec.GetColumn();
294 
295  const size_t num_comp_units = context.module_sp->GetNumCompileUnits();
296  for (size_t i = 0; i < num_comp_units; i++) {
297  CompUnitSP cu_sp(context.module_sp->GetCompileUnitAtIndex(i));
298  if (cu_sp) {
299  if (filter.CompUnitPasses(*cu_sp))
300  cu_sp->ResolveSymbolContext(m_location_spec, eSymbolContextEverything,
301  sc_list);
302  }
303  }
304 
305  FilterContexts(sc_list);
306 
307  DeduceSourceMapping(sc_list);
308 
309  StreamString s;
310  s.Printf("for %s:%d ",
312  line);
313 
314  SetSCMatchesByLine(filter, sc_list, m_skip_prologue, s.GetString(), line,
315  column);
316 
318 }
319 
322 }
323 
325  s->Printf("file = '%s', line = %u, ",
326  m_location_spec.GetFileSpec().GetPath().c_str(),
327  m_location_spec.GetLine().value_or(0));
328  auto column = m_location_spec.GetColumn();
329  if (column)
330  s->Printf("column = %u, ", *column);
331  s->Printf("exact_match = %d", m_location_spec.GetExactMatch());
332 }
333 
335 
336 lldb::BreakpointResolverSP
338  lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileLine(
339  breakpoint, GetOffset(), m_skip_prologue, m_location_spec));
340 
341  return ret_sp;
342 }
lldb_private::SourceLocationSpec::GetFileSpec
FileSpec GetFileSpec() const
Definition: SourceLocationSpec.h:166
lldb_private::BreakpointResolverFileLine::SearchCallback
Searcher::CallbackReturn SearchCallback(SearchFilter &filter, SymbolContext &context, Address *addr) override
Definition: BreakpointResolverFileLine.cpp:272
lldb_private::SymbolContext::block
Block * block
The Block for a given query.
Definition: SymbolContext.h:321
lldb_private::TargetProperties::GetAutoSourceMapRelative
bool GetAutoSourceMapRelative() const
Definition: Target.cpp:4279
lldb_private::Declaration::IsValid
bool IsValid() const
Definition: Declaration.h:145
lldb_private::LineEntry::file
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:140
lldb_private::StructuredData::Dictionary
Definition: StructuredData.h:352
lldb_private::BreakpointResolverFileLine::CreateFromStructuredData
static BreakpointResolver * CreateFromStructuredData(const lldb::BreakpointSP &bkpt, const StructuredData::Dictionary &data_dict, Status &error)
Definition: BreakpointResolverFileLine.cpp:32
lldb::SearchDepth
SearchDepth
Definition: lldb-enumerations.h:283
lldb_private::BreakpointResolver::OptionNames::FileName
@ FileName
lldb_private::BreakpointResolverFileLine::GetDepth
lldb::SearchDepth GetDepth() override
Definition: BreakpointResolverFileLine.cpp:320
lldb_private::BreakpointResolver::OptionNames::Inlines
@ Inlines
CompileUnit.h
lldb_private::SourceLocationSpec
Definition: SourceLocationSpec.h:27
lldb_private::BreakpointResolverFileLine::m_removed_prefix_opt
llvm::Optional< llvm::StringRef > m_removed_prefix_opt
Definition: BreakpointResolverFileLine.h:68
LLDB_INVALID_COLUMN_NUMBER
#define LLDB_INVALID_COLUMN_NUMBER
Definition: lldb-defines.h:87
lldb_private::BreakpointResolver::OptionNames::SkipPrologue
@ SkipPrologue
Module.h
lldb_private::PathMappingList::AppendUnique
bool AppendUnique(llvm::StringRef path, llvm::StringRef replacement, bool notify)
Append <path, replacement> pair without duplication.
Definition: PathMappingList.cpp:79
lldb_private::FileSpec::GetPathStyle
Style GetPathStyle() const
Definition: FileSpec.cpp:330
BreakpointLocation.h
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::SymbolContextList::GetContextAtIndex
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
Definition: SymbolContext.cpp:1258
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:192
lldb_private::FileSpec::GetFilename
const ConstString & GetFilename() const
Filename string const get accessor.
Definition: FileSpec.h:239
lldb_private::Declaration::GetFile
FileSpec & GetFile()
Get accessor for file specification.
Definition: Declaration.h:107
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::FileLineResolver
Definition: FileLineResolver.h:27
lldb_private::StructuredData::Dictionary::GetValueForKeyAsInteger
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
Definition: StructuredData.h:413
Target.h
lldb_private::FileSpec
Definition: FileSpec.h:55
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::BreakpointResolver::OptionNames::LineNumber
@ LineNumber
lldb_private::BreakpointResolverFileLine::m_skip_prologue
bool m_skip_prologue
Definition: BreakpointResolverFileLine.h:65
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:201
lldb_private::SearchFilter
General Outline: Provides the callback and search depth for the SearchFilter search.
Definition: SearchFilter.h:83
Log.h
lldb_private::BreakpointResolverFileLine::DeduceSourceMapping
void DeduceSourceMapping(SymbolContextList &sc_list)
Definition: BreakpointResolverFileLine.cpp:193
lldb_private::BreakpointResolverFileLine::SerializeToStructuredData
StructuredData::ObjectSP SerializeToStructuredData() override
Definition: BreakpointResolverFileLine.cpp:97
lldb_private::BreakpointResolver::OptionNames::Column
@ Column
lldb_private::StructuredData::ObjectSP
std::shared_ptr< Object > ObjectSP
Definition: StructuredData.h:59
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
StreamString.h
lldb_private::BreakpointResolverFileLine::CopyForBreakpoint
lldb::BreakpointResolverSP CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override
Definition: BreakpointResolverFileLine.cpp:337
lldb_private::SymbolContextList::GetSize
uint32_t GetSize() const
Get accessor for a symbol context list size.
Definition: SymbolContext.cpp:1274
lldb_private::Searcher::CallbackReturn
CallbackReturn
Definition: SearchFilter.h:44
lldb_private::TargetStats::IncreaseSourceMapDeduceCount
void IncreaseSourceMapDeduceCount()
Definition: Statistics.cpp:165
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::LLDBLog::Breakpoints
@ Breakpoints
lldb_private::StructuredData::DictionarySP
std::shared_ptr< Dictionary > DictionarySP
Definition: StructuredData.h:67
lldb_private::BreakpointResolverFileLine::m_location_spec
SourceLocationSpec m_location_spec
Definition: BreakpointResolverFileLine.h:64
lldb_private::LineEntry::line
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:143
lldb_private::FunctionInfo::GetDeclaration
Declaration & GetDeclaration()
Get accessor for the declaration information.
Definition: Function.cpp:53
lldb_private::Function::GetStartLineSourceInfo
void GetStartLineSourceInfo(FileSpec &source_file, uint32_t &line_no)
Find the file and line number of the source location of the start of the function.
Definition: Function.cpp:244
lldb::eSearchDepthModule
@ eSearchDepthModule
Definition: lldb-enumerations.h:286
lldb_private::BreakpointResolver
General Outline: The BreakpointResolver is a Searcher.
Definition: BreakpointResolver.h:35
lldb_private::BreakpointResolver::WrapOptionsDict
StructuredData::DictionarySP WrapOptionsDict(StructuredData::DictionarySP options_dict_sp)
Definition: BreakpointResolver.cpp:149
lldb_private::BreakpointResolverFileLine::BreakpointResolverFileLine
BreakpointResolverFileLine(const lldb::BreakpointSP &bkpt, lldb::addr_t offset, bool skip_prologue, const SourceLocationSpec &location_spec, llvm::Optional< llvm::StringRef > removed_prefix_opt=llvm::None)
lldb_private::Declaration::GetLine
uint32_t GetLine() const
Get accessor for the declaration line number.
Definition: Declaration.h:120
lldb_private::Status
Definition: Status.h:44
lldb_private::FileSpec::IsRelative
bool IsRelative() const
Returns true if the filespec represents a relative path.
Definition: FileSpec.cpp:491
lldb_private::Block
Definition: Block.h:41
uint32_t
lldb_private::Target::GetStatistics
TargetStats & GetStatistics()
Definition: Target.h:1572
lldb_private::FileSpec::GetDirectory
const ConstString & GetDirectory() const
Directory string const get accessor.
Definition: FileSpec.h:222
lldb_private::Address
Definition: Address.h:59
lldb_private::BreakpointResolver::SetSCMatchesByLine
void SetSCMatchesByLine(SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue, llvm::StringRef log_ident, uint32_t line=0, llvm::Optional< uint16_t > column=llvm::None)
Takes a symbol context list of matches which supposedly represent the same file and line number in a ...
Definition: BreakpointResolver.cpp:202
lldb_private::BreakpointResolver::GetKey
static const char * GetKey(OptionNames enum_value)
Definition: BreakpointResolver.h:193
lldb_private::BreakpointResolverFileLine::FilterContexts
void FilterContexts(SymbolContextList &sc_list)
Definition: BreakpointResolverFileLine.cpp:125
lldb_private::SymbolContext::module_sp
lldb::ModuleSP module_sp
The Module for a given query.
Definition: SymbolContext.h:318
uint16_t
lldb_private::SearchFilter::CompUnitPasses
virtual bool CompUnitPasses(FileSpec &fileSpec)
Call this method with a FileSpec to see if file spec passes the filter as the name of a compilation u...
Definition: SearchFilter.cpp:143
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:337
lldb_private::FileSpec::IsCaseSensitive
bool IsCaseSensitive() const
Case sensitivity of path.
Definition: FileSpec.h:204
Function.h
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::BreakpointResolver::GetOffset
lldb::addr_t GetOffset() const
Definition: BreakpointResolver.h:77
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::SourceLocationSpec::GetExactMatch
bool GetExactMatch() const
Definition: SourceLocationSpec.h:174
lldb_private::BreakpointResolverFileLine::GetDescription
void GetDescription(Stream *s) override
Prints a canonical description for the breakpoint to the stream s.
Definition: BreakpointResolverFileLine.cpp:324
lldb_private::SourceLocationSpec::GetColumn
llvm::Optional< uint16_t > GetColumn() const
Definition: SourceLocationSpec.cpp:76
lldb_private::TargetProperties::GetSourcePathMap
PathMappingList & GetSourcePathMap() const
Definition: Target.cpp:4270
lldb_private::Log
Definition: Log.h:115
lldb_private::SourceLocationSpec::GetCheckInlines
bool GetCheckInlines() const
Definition: SourceLocationSpec.h:172
lldb_private::Block::GetInlinedFunctionInfo
const InlineFunctionInfo * GetInlinedFunctionInfo() const
Get const accessor for any inlined function information.
Definition: Block.h:276
lldb_private::StructuredData::Dictionary::GetValueForKeyAsString
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
Definition: StructuredData.h:433
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
lldb_private::BreakpointResolverFileLine::Dump
void Dump(Stream *s) const override
Standard "Dump" method. At present it does nothing.
Definition: BreakpointResolverFileLine.cpp:334
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:364
lldb_private::BreakpointResolver::OptionNames::ExactMatch
@ ExactMatch
lldb_private::Declaration
Definition: Declaration.h:24
lldb_private::StructuredData::Dictionary::GetValueForKeyAsBoolean
bool GetValueForKeyAsBoolean(llvm::StringRef key, bool &result) const
Definition: StructuredData.h:400
lldb
Definition: SBAddress.h:15
lldb_private::BreakpointResolver::GetBreakpoint
lldb::BreakpointSP GetBreakpoint() const
This gets the breakpoint for this resolver.
Definition: BreakpointResolver.h:62
BreakpointResolverFileLine.h
lldb_private::FileSpec::Equal
static bool Equal(const FileSpec &a, const FileSpec &b, bool full)
Definition: FileSpec.cpp:292
LLDBLog.h
lldb_private::Block::GetContainingInlinedBlock
Block * GetContainingInlinedBlock()
Get the inlined block that contains this block.
Definition: Block.cpp:208
lldb_private::SourceLocationSpec::GetLine
llvm::Optional< uint32_t > GetLine() const
Definition: SourceLocationSpec.cpp:69
lldb_private::SymbolContextList::RemoveContextAtIndex
bool RemoveContextAtIndex(size_t idx)
Definition: SymbolContext.cpp:1266
lldb_private::Searcher::eCallbackReturnContinue
@ eCallbackReturnContinue
Definition: SearchFilter.h:46