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 {
213  is_prologue_end(false), is_epilogue_begin(false),
214  is_terminal_entry(false) {}
215 
216  Entry(lldb::addr_t _file_addr, uint32_t _line, uint16_t _column,
217  uint16_t _file_idx, bool _is_start_of_statement,
218  bool _is_start_of_basic_block, bool _is_prologue_end,
219  bool _is_epilogue_begin, bool _is_terminal_entry)
220  : file_addr(_file_addr), line(_line),
221  is_start_of_statement(_is_start_of_statement),
222  is_start_of_basic_block(_is_start_of_basic_block),
223  is_prologue_end(_is_prologue_end),
224  is_epilogue_begin(_is_epilogue_begin),
225  is_terminal_entry(_is_terminal_entry), column(_column),
226  file_idx(_file_idx) {}
227 
228  int bsearch_compare(const void *key, const void *arrmem);
229 
230  void Clear() {
232  line = 0;
233  column = 0;
234  file_idx = 0;
235  is_start_of_statement = false;
236  is_start_of_basic_block = false;
237  is_prologue_end = false;
238  is_epilogue_begin = false;
239  is_terminal_entry = false;
240  }
241 
242  static int Compare(const Entry &lhs, const Entry &rhs) {
243 // Compare the sections before calling
244 #define SCALAR_COMPARE(a, b) \
245  if (a < b) \
246  return -1; \
247  if (a > b) \
248  return +1
250  SCALAR_COMPARE(lhs.line, rhs.line);
251  SCALAR_COMPARE(lhs.column, rhs.column);
254  // rhs and lhs reversed on purpose below.
257  // rhs and lhs reversed on purpose below.
259  SCALAR_COMPARE(lhs.file_idx, rhs.file_idx);
260 #undef SCALAR_COMPARE
261  return 0;
262  }
263 
265  public:
266  LessThanBinaryPredicate(LineTable *line_table);
267  bool operator()(const LineTable::Entry &, const LineTable::Entry &) const;
268  bool operator()(const std::unique_ptr<LineSequence> &,
269  const std::unique_ptr<LineSequence> &) const;
270 
271  protected:
273  };
274 
275  static bool EntryAddressLessThan(const Entry &lhs, const Entry &rhs) {
276  return lhs.file_addr < rhs.file_addr;
277  }
278 
279  // Member variables.
280  /// The file address for this line entry.
282  /// The source line number, or zero if there is no line number
283  /// information.
285  /// Indicates this entry is the beginning of a statement.
287  /// Indicates this entry is the beginning of a basic block.
289  /// Indicates this entry is one (of possibly many) where execution
290  /// should be suspended for an entry breakpoint of a function.
292  /// Indicates this entry is one (of possibly many) where execution
293  /// should be suspended for an exit breakpoint of a function.
295  /// Indicates this entry is that of the first byte after the end
296  /// of a sequence of target machine instructions.
298  /// The column number of the source line, or zero if there is no
299  /// column information.
301  /// The file index into CompileUnit's file table, or zero if there
302  /// is no file information.
304  };
305 
310  };
311 
312  // Types
313  typedef std::vector<lldb_private::Section *>
314  section_collection; ///< The collection type for the sections.
315  typedef std::vector<Entry>
316  entry_collection; ///< The collection type for the line entries.
317  // Member variables.
319  *m_comp_unit; ///< The compile unit that this line table belongs to.
321  m_entries; ///< The collection of line entries in this line table.
322 
323  // Helper class
325  public:
326  LineSequenceImpl() = default;
327 
328  ~LineSequenceImpl() override = default;
329 
330  void Clear() override;
331 
333  m_entries; ///< The collection of line entries in this sequence.
334  };
335 
336  bool ConvertEntryAtIndexToLineEntry(uint32_t idx, LineEntry &line_entry);
337 
338 private:
339  LineTable(const LineTable &) = delete;
340  const LineTable &operator=(const LineTable &) = delete;
341 
342  template <typename T>
344  uint32_t start_idx, T file_idx,
345  const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr,
346  std::function<bool(T, uint16_t)> file_idx_matcher) {
347  const size_t count = m_entries.size();
348  size_t best_match = UINT32_MAX;
349 
350  if (!line_entry_ptr)
351  return best_match;
352 
353  const uint32_t line = src_location_spec.GetLine().getValueOr(0);
354  const uint16_t column =
355  src_location_spec.GetColumn().getValueOr(LLDB_INVALID_COLUMN_NUMBER);
356  const bool exact_match = src_location_spec.GetExactMatch();
357 
358  for (size_t idx = start_idx; idx < count; ++idx) {
359  // Skip line table rows that terminate the previous row (is_terminal_entry
360  // is non-zero)
361  if (m_entries[idx].is_terminal_entry)
362  continue;
363 
364  if (!file_idx_matcher(file_idx, m_entries[idx].file_idx))
365  continue;
366 
367  // Exact match always wins. Otherwise try to find the closest line > the
368  // desired line.
369  // FIXME: Maybe want to find the line closest before and the line closest
370  // after and if they're not in the same function, don't return a match.
371 
372  if (column == LLDB_INVALID_COLUMN_NUMBER) {
373  if (m_entries[idx].line < line) {
374  continue;
375  } else if (m_entries[idx].line == line) {
376  ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
377  return idx;
378  } else if (!exact_match) {
379  if (best_match == UINT32_MAX ||
380  m_entries[idx].line < m_entries[best_match].line)
381  best_match = idx;
382  }
383  } else {
384  if (m_entries[idx].line < line) {
385  continue;
386  } else if (m_entries[idx].line == line &&
387  m_entries[idx].column == column) {
388  ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
389  return idx;
390  } else if (!exact_match) {
391  if (best_match == UINT32_MAX)
392  best_match = idx;
393  else if (m_entries[idx].line < m_entries[best_match].line)
394  best_match = idx;
395  else if (m_entries[idx].line == m_entries[best_match].line)
396  if (m_entries[idx].column &&
397  m_entries[idx].column < m_entries[best_match].column)
398  best_match = idx;
399  }
400  }
401  }
402 
403  if (best_match != UINT32_MAX) {
404  if (line_entry_ptr)
405  ConvertEntryAtIndexToLineEntry(best_match, *line_entry_ptr);
406  return best_match;
407  }
408  return UINT32_MAX;
409  }
410 };
411 
412 } // namespace lldb_private
413 
414 #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:242
lldb_private::LineTable::m_entries
entry_collection m_entries
The collection of line entries in this line table.
Definition: LineTable.h:321
lldb_private::SourceLocationSpec
Definition: SourceLocationSpec.h:27
LLDB_INVALID_COLUMN_NUMBER
#define LLDB_INVALID_COLUMN_NUMBER
Definition: lldb-defines.h:99
lldb_private::LineTable::Entry::file_addr
lldb::addr_t file_addr
The file address for this line entry.
Definition: LineTable.h:281
lldb_private::LineTable::Entry::LessThanBinaryPredicate
Definition: LineTable.h:264
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:303
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:291
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:216
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::LineTable::~LineTable
~LineTable()
Destructor.
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:451
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:343
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:297
lldb_private::LineTable::LineSequenceImpl
Definition: LineTable.h:324
LineEntry.h
lldb_private::LineTable::Entry::Clear
void Clear()
Definition: LineTable.h:230
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:309
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:294
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:308
lldb_private::LineTable::Entry::LessThanBinaryPredicate::m_line_table
LineTable * m_line_table
Definition: LineTable.h:272
lldb_private::LineTable::LineSequenceImpl::m_entries
entry_collection m_entries
The collection of line entries in this sequence.
Definition: LineTable.h:333
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:286
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:314
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:307
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:284
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:316
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:306
lldb_private::LineTable::Entry::EntryAddressLessThan
static bool EntryAddressLessThan(const Entry &lhs, const Entry &rhs)
Definition: LineTable.h:275
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
Definition: lldb-defines.h:86
lldb_private::LineTable::m_comp_unit
CompileUnit * m_comp_unit
The compile unit that this line table belongs to.
Definition: LineTable.h:319
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:300
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:288
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()
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