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