LLDB  mainline
LineTable.h
Go to the documentation of this file.
1 //===-- LineTable.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_SYMBOL_LINETABLE_H
10 #define LLDB_SYMBOL_LINETABLE_H
11 
12 #include "lldb/Core/Address.h"
13 #include "lldb/Core/ModuleChild.h"
14 #include "lldb/Core/Section.h"
16 #include "lldb/Symbol/LineEntry.h"
17 #include "lldb/Utility/RangeMap.h"
18 #include "lldb/lldb-private.h"
19 #include <vector>
20 
21 namespace lldb_private {
22 
23 /// \class LineSequence LineTable.h "lldb/Symbol/LineTable.h" An abstract base
24 /// class used during symbol table creation.
25 class LineSequence {
26 public:
27  LineSequence();
28 
29  virtual ~LineSequence() = default;
30 
31  virtual void Clear() = 0;
32 
33 private:
34  LineSequence(const LineSequence &) = delete;
35  const LineSequence &operator=(const LineSequence &) = delete;
36 };
37 
38 /// \class LineTable LineTable.h "lldb/Symbol/LineTable.h"
39 /// A line table class.
40 class LineTable {
41 public:
42  /// Construct with compile unit.
43  ///
44  /// \param[in] comp_unit
45  /// The compile unit to which this line table belongs.
46  LineTable(CompileUnit *comp_unit);
47 
48  /// Construct with entries found in \a sequences.
49  ///
50  /// \param[in] sequences
51  /// Unsorted list of line sequences.
52  LineTable(CompileUnit *comp_unit,
53  std::vector<std::unique_ptr<LineSequence>> &&sequences);
54 
55  /// Destructor.
56  ~LineTable();
57 
58  /// Adds a new line entry to this line table.
59  ///
60  /// All line entries are maintained in file address order.
61  ///
62  /// \param[in] line_entry
63  /// A const reference to a new line_entry to add to this line
64  /// table.
65  ///
66  /// \see Address::DumpStyle
67  // void
68  // AddLineEntry (const LineEntry& line_entry);
69 
70  // Called when you can't guarantee the addresses are in increasing order
71  void InsertLineEntry(lldb::addr_t file_addr, uint32_t line, uint16_t column,
72  uint16_t file_idx, bool is_start_of_statement,
73  bool is_start_of_basic_block, bool is_prologue_end,
74  bool is_epilogue_begin, bool is_terminal_entry);
75 
76  // Used to instantiate the LineSequence helper class
77  static std::unique_ptr<LineSequence> CreateLineSequenceContainer();
78 
79  // Append an entry to a caller-provided collection that will later be
80  // inserted in this line table.
81  static void AppendLineEntryToSequence(LineSequence *sequence, lldb::addr_t file_addr,
82  uint32_t line, uint16_t column,
83  uint16_t file_idx, bool is_start_of_statement,
84  bool is_start_of_basic_block,
85  bool is_prologue_end, bool is_epilogue_begin,
86  bool is_terminal_entry);
87 
88  // Insert a sequence of entries into this line table.
89  void InsertSequence(LineSequence *sequence);
90 
91  /// Dump all line entries in this line table to the stream \a s.
92  ///
93  /// \param[in] s
94  /// The stream to which to dump the object description.
95  ///
96  /// \param[in] style
97  /// The display style for the address.
98  ///
99  /// \see Address::DumpStyle
100  void Dump(Stream *s, Target *target, Address::DumpStyle style,
101  Address::DumpStyle fallback_style, bool show_line_ranges);
102 
103  void GetDescription(Stream *s, Target *target, lldb::DescriptionLevel level);
104 
105  /// Find a line entry that contains the section offset address \a so_addr.
106  ///
107  /// \param[in] so_addr
108  /// A section offset address object containing the address we
109  /// are searching for.
110  ///
111  /// \param[out] line_entry
112  /// A copy of the line entry that was found if \b true is
113  /// returned, otherwise \a entry is left unmodified.
114  ///
115  /// \param[out] index_ptr
116  /// A pointer to a 32 bit integer that will get the actual line
117  /// entry index if it is not nullptr.
118  ///
119  /// \return
120  /// Returns \b true if \a so_addr is contained in a line entry
121  /// in this line table, \b false otherwise.
122  bool FindLineEntryByAddress(const Address &so_addr, LineEntry &line_entry,
123  uint32_t *index_ptr = nullptr);
124 
125  /// Find a line entry index that has a matching file index and source line
126  /// number.
127  ///
128  /// Finds the next line entry that has a matching \a file_idx and source
129  /// line number \a line starting at the \a start_idx entries into the line
130  /// entry collection.
131  ///
132  /// \param[in] start_idx
133  /// The number of entries to skip when starting the search.
134  ///
135  /// \param[out] file_idx
136  /// The file index to search for that should be found prior
137  /// to calling this function using the following functions:
138  /// CompileUnit::GetSupportFiles()
139  /// FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const
140  ///
141  /// \param[in] src_location_spec
142  /// The source location specifier to match.
143  ///
144  /// \param[out] line_entry_ptr
145  /// A pointer to a line entry object that will get a copy of
146  /// the line entry if \b true is returned, otherwise \a
147  /// line_entry is left untouched.
148  ///
149  /// \return
150  /// Returns \b true if a matching line entry is found in this
151  /// line table, \b false otherwise.
152  ///
153  /// \see CompileUnit::GetSupportFiles()
154  /// \see FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const
155  uint32_t
156  FindLineEntryIndexByFileIndex(uint32_t start_idx, uint32_t file_idx,
157  const SourceLocationSpec &src_location_spec,
158  LineEntry *line_entry_ptr);
159 
161  uint32_t start_idx, const std::vector<uint32_t> &file_idx,
162  const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr);
163 
164  size_t FineLineEntriesForFileIndex(uint32_t file_idx, bool append,
165  SymbolContextList &sc_list);
166 
167  /// Get the line entry from the line table at index \a idx.
168  ///
169  /// \param[in] idx
170  /// An index into the line table entry collection.
171  ///
172  /// \return
173  /// A valid line entry if \a idx is a valid index, or an invalid
174  /// line entry if \a idx is not valid.
175  ///
176  /// \see LineTable::GetSize()
177  /// \see LineEntry::IsValid() const
178  bool GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry);
179 
180  /// Gets the size of the line table in number of line table entries.
181  ///
182  /// \return
183  /// The number of line table entries in this line table.
184  uint32_t GetSize() const;
185 
188 
189  /// Gets all contiguous file address ranges for the entire line table.
190  ///
191  /// \param[out] file_ranges
192  /// A collection of file address ranges that will be filled in
193  /// by this function.
194  ///
195  /// \param[out] append
196  /// If \b true, then append to \a file_ranges, otherwise clear
197  /// \a file_ranges prior to adding any ranges.
198  ///
199  /// \return
200  /// The number of address ranges added to \a file_ranges
202  bool append);
203 
206 
207  LineTable *LinkLineTable(const FileRangeMap &file_range_map);
208 
209 protected:
210  struct Entry {
214  is_prologue_end(false), is_epilogue_begin(false),
215  is_terminal_entry(false), column(0), file_idx(0) {}
216 
217  Entry(lldb::addr_t _file_addr, uint32_t _line, uint16_t _column,
218  uint16_t _file_idx, bool _is_start_of_statement,
219  bool _is_start_of_basic_block, bool _is_prologue_end,
220  bool _is_epilogue_begin, bool _is_terminal_entry)
221  : file_addr(_file_addr), line(_line),
222  is_start_of_statement(_is_start_of_statement),
223  is_start_of_basic_block(_is_start_of_basic_block),
224  is_prologue_end(_is_prologue_end),
225  is_epilogue_begin(_is_epilogue_begin),
226  is_terminal_entry(_is_terminal_entry), column(_column),
227  file_idx(_file_idx) {}
228 
229  int bsearch_compare(const void *key, const void *arrmem);
230 
231  void Clear() {
233  line = 0;
234  column = 0;
235  file_idx = 0;
236  is_start_of_statement = false;
237  is_start_of_basic_block = false;
238  is_prologue_end = false;
239  is_epilogue_begin = false;
240  is_terminal_entry = false;
241  }
242 
243  static int Compare(const Entry &lhs, const Entry &rhs) {
244 // Compare the sections before calling
245 #define SCALAR_COMPARE(a, b) \
246  if (a < b) \
247  return -1; \
248  if (a > b) \
249  return +1
251  SCALAR_COMPARE(lhs.line, rhs.line);
252  SCALAR_COMPARE(lhs.column, rhs.column);
255  // rhs and lhs reversed on purpose below.
258  // rhs and lhs reversed on purpose below.
260  SCALAR_COMPARE(lhs.file_idx, rhs.file_idx);
261 #undef SCALAR_COMPARE
262  return 0;
263  }
264 
266  public:
267  LessThanBinaryPredicate(LineTable *line_table);
268  bool operator()(const LineTable::Entry &, const LineTable::Entry &) const;
269  bool operator()(const std::unique_ptr<LineSequence> &,
270  const std::unique_ptr<LineSequence> &) const;
271 
272  protected:
274  };
275 
276  static bool EntryAddressLessThan(const Entry &lhs, const Entry &rhs) {
277  return lhs.file_addr < rhs.file_addr;
278  }
279 
280  // Member variables.
281  /// The file address for this line entry.
283  /// The source line number, or zero if there is no line number
284  /// information.
286  /// Indicates this entry is the beginning of a statement.
288  /// Indicates this entry is the beginning of a basic block.
290  /// Indicates this entry is one (of possibly many) where execution
291  /// should be suspended for an entry breakpoint of a function.
293  /// Indicates this entry is one (of possibly many) where execution
294  /// should be suspended for an exit breakpoint of a function.
296  /// Indicates this entry is that of the first byte after the end
297  /// of a sequence of target machine instructions.
299  /// The column number of the source line, or zero if there is no
300  /// column information.
302  /// The file index into CompileUnit's file table, or zero if there
303  /// is no file information.
305  };
306 
311  };
312 
313  // Types
314  typedef std::vector<lldb_private::Section *>
315  section_collection; ///< The collection type for the sections.
316  typedef std::vector<Entry>
317  entry_collection; ///< The collection type for the line entries.
318  // Member variables.
320  *m_comp_unit; ///< The compile unit that this line table belongs to.
322  m_entries; ///< The collection of line entries in this line table.
323 
324  // Helper class
326  public:
327  LineSequenceImpl() = default;
328 
329  ~LineSequenceImpl() override = default;
330 
331  void Clear() override;
332 
334  m_entries; ///< The collection of line entries in this sequence.
335  };
336 
337  bool ConvertEntryAtIndexToLineEntry(uint32_t idx, LineEntry &line_entry);
338 
339 private:
340  LineTable(const LineTable &) = delete;
341  const LineTable &operator=(const LineTable &) = delete;
342 
343  template <typename T>
345  uint32_t start_idx, T file_idx,
346  const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr,
347  std::function<bool(T, uint16_t)> file_idx_matcher) {
348  const size_t count = m_entries.size();
349  size_t best_match = UINT32_MAX;
350 
351  if (!line_entry_ptr)
352  return best_match;
353 
354  const uint32_t line = src_location_spec.GetLine().getValueOr(0);
355  const uint16_t column =
356  src_location_spec.GetColumn().getValueOr(LLDB_INVALID_COLUMN_NUMBER);
357  const bool exact_match = src_location_spec.GetExactMatch();
358 
359  for (size_t idx = start_idx; idx < count; ++idx) {
360  // Skip line table rows that terminate the previous row (is_terminal_entry
361  // is non-zero)
362  if (m_entries[idx].is_terminal_entry)
363  continue;
364 
365  if (!file_idx_matcher(file_idx, m_entries[idx].file_idx))
366  continue;
367 
368  // Exact match always wins. Otherwise try to find the closest line > the
369  // desired line.
370  // FIXME: Maybe want to find the line closest before and the line closest
371  // after and if they're not in the same function, don't return a match.
372 
373  if (column == LLDB_INVALID_COLUMN_NUMBER) {
374  if (m_entries[idx].line < line) {
375  continue;
376  } else if (m_entries[idx].line == line) {
377  ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
378  return idx;
379  } else if (!exact_match) {
380  if (best_match == UINT32_MAX ||
381  m_entries[idx].line < m_entries[best_match].line)
382  best_match = idx;
383  }
384  } else {
385  if (m_entries[idx].line < line) {
386  continue;
387  } else if (m_entries[idx].line == line &&
388  m_entries[idx].column == column) {
389  ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
390  return idx;
391  } else if (!exact_match) {
392  if (best_match == UINT32_MAX)
393  best_match = idx;
394  else if (m_entries[idx].line < m_entries[best_match].line)
395  best_match = idx;
396  else if (m_entries[idx].line == m_entries[best_match].line)
397  if (m_entries[idx].column &&
398  m_entries[idx].column < m_entries[best_match].column)
399  best_match = idx;
400  }
401  }
402  }
403 
404  if (best_match != UINT32_MAX) {
405  if (line_entry_ptr)
406  ConvertEntryAtIndexToLineEntry(best_match, *line_entry_ptr);
407  return best_match;
408  }
409  return UINT32_MAX;
410  }
411 };
412 
413 } // namespace lldb_private
414 
415 #endif // LLDB_SYMBOL_LINETABLE_H
lldb_private::LineTable::FindLineEntryByAddress
bool FindLineEntryByAddress(const Address &so_addr, LineEntry &line_entry, uint32_t *index_ptr=nullptr)
Find a line entry that contains the section offset address so_addr.
Definition: LineTable.cpp:188
lldb_private::LineTable::Entry::Compare
static int Compare(const Entry &lhs, const Entry &rhs)
Definition: LineTable.h:243
lldb_private::LineTable::m_entries
entry_collection m_entries
The collection of line entries in this line table.
Definition: LineTable.h:322
lldb_private::SourceLocationSpec
Definition: SourceLocationSpec.h:27
LLDB_INVALID_COLUMN_NUMBER
#define LLDB_INVALID_COLUMN_NUMBER
Definition: lldb-defines.h:98
lldb_private::LineTable::Entry::file_addr
lldb::addr_t file_addr
The file address for this line entry.
Definition: LineTable.h:282
lldb_private::LineTable::Entry::LessThanBinaryPredicate
Definition: LineTable.h:265
lldb_private::LineSequence
Definition: LineTable.h:25
lldb_private::LineTable::Entry::file_idx
uint16_t file_idx
The file index into CompileUnit's file table, or zero if there is no file information.
Definition: LineTable.h:304
lldb_private::LineTable::GetLineEntryAtIndex
bool GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry)
Get the line entry from the line table at index idx.
Definition: LineTable.cpp:179
lldb_private::LineTable::Entry::is_prologue_end
uint32_t is_prologue_end
Indicates this entry is one (of possibly many) where execution should be suspended for an entry break...
Definition: LineTable.h:292
lldb_private::LineTable::LineSequenceImpl::LineSequenceImpl
LineSequenceImpl()=default
lldb_private::LineTable::Entry::Entry
Entry(lldb::addr_t _file_addr, uint32_t _line, uint16_t _column, uint16_t _file_idx, bool _is_start_of_statement, bool _is_start_of_basic_block, bool _is_prologue_end, bool _is_epilogue_begin, bool _is_terminal_entry)
Definition: LineTable.h:217
lldb_private::SymbolContextList
Definition: SymbolContext.h:378
lldb_private::LineTable::~LineTable
~LineTable()
Destructor.
Definition: LineTable.cpp:37
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
RangeMap.h
lldb_private::Target
Definition: Target.h:445
Section.h
lldb_private::CompileUnit
Definition: CompileUnit.h:38
lldb_private::LineTable
Definition: LineTable.h:40
lldb_private::LineTable::FindLineEntryIndexByFileIndexImpl
uint32_t FindLineEntryIndexByFileIndexImpl(uint32_t start_idx, T file_idx, const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr, std::function< bool(T, uint16_t)> file_idx_matcher)
Definition: LineTable.h:344
lldb_private::LineTable::GetDescription
void GetDescription(Stream *s, Target *target, lldb::DescriptionLevel level)
Definition: LineTable.cpp:370
SourceLocationSpec.h
lldb_private::LineTable::FineLineEntriesForFileIndex
size_t FineLineEntriesForFileIndex(uint32_t file_idx, bool append, SymbolContextList &sc_list)
Definition: LineTable.cpp:328
lldb_private::LineTable::Entry::is_terminal_entry
uint32_t is_terminal_entry
Indicates this entry is that of the first byte after the end of a sequence of target machine instruct...
Definition: LineTable.h:298
lldb_private::LineTable::LineSequenceImpl
Definition: LineTable.h:325
LineEntry.h
lldb_private::LineTable::Entry::Clear
void Clear()
Definition: LineTable.h:231
lldb_private::LineSequence::~LineSequence
virtual ~LineSequence()=default
SCALAR_COMPARE
#define SCALAR_COMPARE(a, b)
lldb_private::LineTable::EntrySearchInfo::a_entry
Entry * a_entry
Definition: LineTable.h:310
lldb_private::LineTable::Entry::LessThanBinaryPredicate::LessThanBinaryPredicate
LessThanBinaryPredicate(LineTable *line_table)
Definition: LineTable.cpp:145
lldb_private::LineTable::LineTable
LineTable(CompileUnit *comp_unit)
Construct with compile unit.
Definition: LineTable.cpp:21
lldb_private::LineTable::Entry::is_epilogue_begin
uint32_t is_epilogue_begin
Indicates this entry is one (of possibly many) where execution should be suspended for an exit breakp...
Definition: LineTable.h:295
lldb_private::LineTable::LineSequenceImpl::~LineSequenceImpl
~LineSequenceImpl() override=default
lldb_private::LineTable::GetContiguousFileAddressRanges
size_t GetContiguousFileAddressRanges(FileAddressRanges &file_ranges, bool append)
Gets all contiguous file address ranges for the entire line table.
Definition: LineTable.cpp:381
lldb_private::LineTable::Entry::LessThanBinaryPredicate::operator()
bool operator()(const LineTable::Entry &, const LineTable::Entry &) const
lldb_private::LineTable::LinkLineTable
LineTable * LinkLineTable(const FileRangeMap &file_range_map)
Definition: LineTable.cpp:406
lldb_private::LineTable::GetSize
uint32_t GetSize() const
Gets the size of the line table in number of line table entries.
Definition: LineTable.cpp:177
lldb_private::LineTable::InsertSequence
void InsertSequence(LineSequence *sequence)
Definition: LineTable.cpp:105
lldb_private::RangeVector
Definition: RangeMap.h:125
Address.h
lldb_private::LineTable::EntrySearchInfo::a_section
lldb_private::Section * a_section
Definition: LineTable.h:309
lldb_private::LineTable::Entry::LessThanBinaryPredicate::m_line_table
LineTable * m_line_table
Definition: LineTable.h:273
lldb_private::LineTable::LineSequenceImpl::m_entries
entry_collection m_entries
The collection of line entries in this sequence.
Definition: LineTable.h:334
lldb-private.h
lldb_private::Section
Definition: Section.h:96
lldb_private::LineTable::Entry::is_start_of_statement
uint32_t is_start_of_statement
Indicates this entry is the beginning of a statement.
Definition: LineTable.h:287
lldb_private::LineTable::AppendLineEntryToSequence
static void AppendLineEntryToSequence(LineSequence *sequence, lldb::addr_t file_addr, uint32_t line, uint16_t column, uint16_t file_idx, bool is_start_of_statement, bool is_start_of_basic_block, bool is_prologue_end, bool is_epilogue_begin, bool is_terminal_entry)
Definition: LineTable.cpp:69
lldb_private::LineTable::section_collection
std::vector< lldb_private::Section * > section_collection
The collection type for the sections.
Definition: LineTable.h:315
lldb_private::LineTable::Entry::Entry
Entry()
Definition: LineTable.h:211
lldb_private::LineTable::Dump
void Dump(Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_line_ranges)
Dump all line entries in this line table to the stream s.
Definition: LineTable.cpp:356
lldb_private::LineTable::CreateLineSequenceContainer
static std::unique_ptr< LineSequence > CreateLineSequenceContainer()
Definition: LineTable.cpp:65
lldb_private::LineTable::LineSequenceImpl::Clear
void Clear() override
Definition: LineTable.cpp:63
lldb_private::LineTable::EntrySearchInfo::line_table
LineTable * line_table
Definition: LineTable.h:308
uint32_t
lldb_private::LineTable::operator=
const LineTable & operator=(const LineTable &)=delete
lldb_private::LineTable::Entry::line
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineTable.h:285
ModuleChild.h
lldb_private::Address
Definition: Address.h:59
lldb_private::LineTable::entry_collection
std::vector< Entry > entry_collection
The collection type for the line entries.
Definition: LineTable.h:317
lldb_private::LineTable::FindLineEntryIndexByFileIndex
uint32_t FindLineEntryIndexByFileIndex(uint32_t start_idx, uint32_t file_idx, const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr)
Find a line entry index that has a matching file index and source line number.
Definition: LineTable.cpp:305
lldb_private::LineTable::EntrySearchInfo
Definition: LineTable.h:307
lldb_private::LineTable::Entry::EntryAddressLessThan
static bool EntryAddressLessThan(const Entry &lhs, const Entry &rhs)
Definition: LineTable.h:276
lldb_private::LineTable::FileRangeMap
RangeDataVector< lldb::addr_t, lldb::addr_t, lldb::addr_t > FileRangeMap
Definition: LineTable.h:205
lldb_private::RangeDataVector< lldb::addr_t, lldb::addr_t, lldb::addr_t >
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
uint16_t
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
lldb_private::LineTable::m_comp_unit
CompileUnit * m_comp_unit
The compile unit that this line table belongs to.
Definition: LineTable.h:320
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::LineTable::FileAddressRanges
lldb_private::RangeVector< lldb::addr_t, lldb::addr_t, 32 > FileAddressRanges
Definition: LineTable.h:187
lldb_private::LineTable::Entry::column
uint16_t column
The column number of the source line, or zero if there is no column information.
Definition: LineTable.h:301
lldb_private::LineTable::Entry::bsearch_compare
int bsearch_compare(const void *key, const void *arrmem)
lldb_private::SourceLocationSpec::GetExactMatch
bool GetExactMatch() const
Definition: SourceLocationSpec.h:174
lldb_private::SourceLocationSpec::GetColumn
llvm::Optional< uint16_t > GetColumn() const
Definition: SourceLocationSpec.cpp:76
lldb_private::Address::DumpStyle
DumpStyle
Dump styles allow the Address::Dump(Stream *,DumpStyle) const function to display Address contents in...
Definition: Address.h:63
lldb_private::LineTable::Entry::is_start_of_basic_block
uint32_t is_start_of_basic_block
Indicates this entry is the beginning of a basic block.
Definition: LineTable.h:289
lldb_private::LineSequence::operator=
const LineSequence & operator=(const LineSequence &)=delete
lldb_private::LineTable::InsertLineEntry
void InsertLineEntry(lldb::addr_t file_addr, uint32_t line, uint16_t column, uint16_t file_idx, bool is_start_of_statement, bool is_start_of_basic_block, bool is_prologue_end, bool is_epilogue_begin, bool is_terminal_entry)
Adds a new line entry to this line table.
Definition: LineTable.cpp:39
lldb_private::LineTable::ConvertEntryAtIndexToLineEntry
bool ConvertEntryAtIndexToLineEntry(uint32_t idx, LineEntry &line_entry)
Definition: LineTable.cpp:260
lldb_private::LineTable::Entry
Definition: LineTable.h:210
lldb_private::LineSequence::LineSequence
LineSequence()
Definition: LineTable.cpp:61
lldb_private::LineEntry
Definition: LineEntry.h:20
lldb_private::LineSequence::Clear
virtual void Clear()=0
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::SourceLocationSpec::GetLine
llvm::Optional< uint32_t > GetLine() const
Definition: SourceLocationSpec.cpp:69