LLDB  mainline
SBCompileUnit.cpp
Go to the documentation of this file.
1 //===-- SBCompileUnit.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 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBLineEntry.h"
12 #include "lldb/API/SBStream.h"
13 #include "lldb/Core/Module.h"
15 #include "lldb/Symbol/LineEntry.h"
16 #include "lldb/Symbol/LineTable.h"
17 #include "lldb/Symbol/SymbolFile.h"
18 #include "lldb/Symbol/Type.h"
19 #include "lldb/Symbol/TypeList.h"
20 
21 using namespace lldb;
22 using namespace lldb_private;
23 
24 SBCompileUnit::SBCompileUnit() : m_opaque_ptr(nullptr) {
26 }
27 
29  : m_opaque_ptr(lldb_object_ptr) {}
30 
32  : m_opaque_ptr(rhs.m_opaque_ptr) {
34 }
35 
38  SBCompileUnit, operator=,(const lldb::SBCompileUnit &),
39  rhs);
40 
42  return LLDB_RECORD_RESULT(*this);
43 }
44 
46 
49  GetFileSpec);
50 
51  SBFileSpec file_spec;
52  if (m_opaque_ptr)
54  return LLDB_RECORD_RESULT(file_spec);
55 }
56 
59 
60  if (m_opaque_ptr) {
61  LineTable *line_table = m_opaque_ptr->GetLineTable();
62  if (line_table) {
63  return line_table->GetSize();
64  }
65  }
66  return 0;
67 }
68 
72 
73  SBLineEntry sb_line_entry;
74  if (m_opaque_ptr) {
75  LineTable *line_table = m_opaque_ptr->GetLineTable();
76  if (line_table) {
77  LineEntry line_entry;
78  if (line_table->GetLineEntryAtIndex(idx, line_entry))
79  sb_line_entry.SetLineEntry(line_entry);
80  }
81  }
82 
83  return LLDB_RECORD_RESULT(sb_line_entry);
84 }
85 
87  SBFileSpec *inline_file_spec) const {
89  (uint32_t, uint32_t, lldb::SBFileSpec *), start_idx,
90  line, inline_file_spec);
91 
92  const bool exact = true;
93  return FindLineEntryIndex(start_idx, line, inline_file_spec, exact);
94 }
95 
97  SBFileSpec *inline_file_spec,
98  bool exact) const {
100  (uint32_t, uint32_t, lldb::SBFileSpec *, bool),
101  start_idx, line, inline_file_spec, exact);
102 
103  uint32_t index = UINT32_MAX;
104  if (m_opaque_ptr) {
105  FileSpec file_spec;
106  if (inline_file_spec && inline_file_spec->IsValid())
107  file_spec = inline_file_spec->ref();
108  else
109  file_spec = m_opaque_ptr->GetPrimaryFile();
110 
111  index = m_opaque_ptr->FindLineEntry(
112  start_idx, line, inline_file_spec ? inline_file_spec->get() : nullptr,
113  exact, nullptr);
114  }
115 
116  return index;
117 }
118 
121 
122  if (m_opaque_ptr)
123  return m_opaque_ptr->GetSupportFiles().GetSize();
124 
125  return 0;
126 }
127 
130  type_mask);
131 
132  SBTypeList sb_type_list;
133 
134  if (!m_opaque_ptr)
135  return LLDB_RECORD_RESULT(sb_type_list);
136 
137  ModuleSP module_sp(m_opaque_ptr->GetModule());
138  if (!module_sp)
139  return LLDB_RECORD_RESULT(sb_type_list);
140 
141  SymbolFile *symfile = module_sp->GetSymbolFile();
142  if (!symfile)
143  return LLDB_RECORD_RESULT(sb_type_list);
144 
145  TypeClass type_class = static_cast<TypeClass>(type_mask);
146  TypeList type_list;
147  symfile->GetTypes(m_opaque_ptr, type_class, type_list);
148  sb_type_list.m_opaque_up->Append(type_list);
149  return LLDB_RECORD_RESULT(sb_type_list);
150 }
151 
155 
156  SBFileSpec sb_file_spec;
157  if (m_opaque_ptr) {
158  FileSpec spec = m_opaque_ptr->GetSupportFiles().GetFileSpecAtIndex(idx);
159  sb_file_spec.SetFileSpec(spec);
160  }
161 
162 
163  return LLDB_RECORD_RESULT(sb_file_spec);
164 }
165 
167  const SBFileSpec &sb_file,
168  bool full) {
170  (uint32_t, const lldb::SBFileSpec &, bool), start_idx,
171  sb_file, full);
172 
173  if (m_opaque_ptr) {
174  const FileSpecList &support_files = m_opaque_ptr->GetSupportFiles();
175  return support_files.FindFileIndex(start_idx, sb_file.ref(), full);
176  }
177  return 0;
178 }
179 
182 
183  if (m_opaque_ptr)
184  return m_opaque_ptr->GetLanguage();
186 }
187 
190  return this->operator bool();
191 }
192 SBCompileUnit::operator bool() const {
193  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool);
194 
195  return m_opaque_ptr != nullptr;
196 }
197 
198 bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {
200  bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs);
201 
202  return m_opaque_ptr == rhs.m_opaque_ptr;
203 }
204 
205 bool SBCompileUnit::operator!=(const SBCompileUnit &rhs) const {
207  bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &), rhs);
208 
209  return m_opaque_ptr != rhs.m_opaque_ptr;
210 }
211 
213  return m_opaque_ptr;
214 }
215 
217  return *m_opaque_ptr;
218 }
219 
221 
223  m_opaque_ptr = lldb_object_ptr;
224 }
225 
228  description);
229 
230  Stream &strm = description.ref();
231 
232  if (m_opaque_ptr) {
233  m_opaque_ptr->Dump(&strm, false);
234  } else
235  strm.PutCString("No value");
236 
237  return true;
238 }
239 
240 namespace lldb_private {
241 namespace repro {
242 
243 template <>
248  const lldb::SBCompileUnit &,
249  SBCompileUnit, operator=,(const lldb::SBCompileUnit &));
251  ());
258  (uint32_t, uint32_t, lldb::SBFileSpec *, bool));
264  (uint32_t, const lldb::SBFileSpec &, bool));
267  LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ());
269  bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &));
271  bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
273  (lldb::SBStream &));
274 }
275 
276 }
277 }
uint32_t FindLineEntry(uint32_t start_idx, uint32_t line, const FileSpec *file_spec_ptr, bool exact, LineEntry *line_entry)
Find the line entry by line and optional inlined file spec.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
A line table entry class.
Definition: LineEntry.h:20
The registry contains a unique mapping between functions and their ID.
lldb::SBTypeList GetTypes(uint32_t type_mask=lldb::eTypeClassAny)
Get all types matching type_mask from debug info in this compile unit.
A class that represents a running process on the host machine.
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
lldb_private::CompileUnit * m_opaque_ptr
Definition: SBCompileUnit.h:90
const lldb_private::FileSpec & ref() const
Definition: SBFileSpec.cpp:168
bool GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry)
Get the line entry from the line table at index idx.
Definition: LineTable.cpp:179
A file utility class.
Definition: FileSpec.h:56
uint32_t GetSize() const
Gets the size of the line table in number of line table entries.
Definition: LineTable.cpp:177
const lldb::SBCompileUnit & operator=(const lldb::SBCompileUnit &rhs)
lldb::LanguageType GetLanguage()
virtual void GetTypes(lldb_private::SymbolContextScope *sc_scope, lldb::TypeClass type_mask, lldb_private::TypeList &type_list)=0
lldb_private::CompileUnit * get()
bool operator==(const lldb::SBCompileUnit &rhs) const
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
A class that describes a compilation unit.
Definition: CompileUnit.h:37
lldb::SBLineEntry GetLineEntryAtIndex(uint32_t idx) const
void reset(lldb_private::CompileUnit *lldb_object_ptr)
#define UINT32_MAX
Definition: lldb-defines.h:31
const FileSpecList & GetSupportFiles()
Get the compile unit&#39;s support file list.
uint32_t GetNumLineEntries() const
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
LanguageType
Programming language type.
uint32_t FindSupportFileIndex(uint32_t start_idx, const SBFileSpec &sb_file, bool full)
bool GetDescription(lldb::SBStream &description)
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
A line table class.
Definition: LineTable.h:38
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
void RegisterMethods< SBCompileUnit >(Registry &R)
lldb::LanguageType GetLanguage()
void SetFileSpec(const lldb_private::FileSpec &fspec)
Definition: SBFileSpec.cpp:170
uint32_t FindLineEntryIndex(uint32_t start_idx, uint32_t line, lldb::SBFileSpec *inline_file_spec) const
LineTable * GetLineTable()
Get the line table for the compile unit.
lldb_private::Stream & ref()
Definition: SBStream.cpp:178
void Dump(Stream *s, bool show_context) const
Dump the compile unit contents to the stream s.
#define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature,...)
SBFileSpec GetSupportFileAtIndex(uint32_t idx) const
const lldb_private::CompileUnit & operator*() const
Unknown or invalid language value.
std::unique_ptr< lldb_private::TypeListImpl > m_opaque_up
Definition: SBType.h:255
Definition: SBAddress.h:15
const FileSpec & GetPrimaryFile() const
Return the primary source file associated with this compile unit.
Definition: CompileUnit.h:226
const lldb_private::CompileUnit * operator->() const
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
lldb::SBFileSpec GetFileSpec() const
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
void SetLineEntry(const lldb_private::LineEntry &lldb_object_ref)
Definition: SBLineEntry.cpp:47
uint32_t GetNumSupportFiles() const
#define LLDB_RECORD_RESULT(Result)
bool operator!=(const lldb::SBCompileUnit &rhs) const
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)