1 //===-- SBSymbolContext.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 
9 #include "lldb/API/SBSymbolContext.h"
10 #include "SBReproducerPrivate.h"
11 #include "Utils.h"
12 #include "lldb/API/SBStream.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Symbol/Function.h"
15 #include "lldb/Symbol/Symbol.h"
16 #include "lldb/Symbol/SymbolContext.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 SBSymbolContext::SBSymbolContext() : m_opaque_up() {
22   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
23 }
24 
25 SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() {
26   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
27                           (const lldb_private::SymbolContext *), sc_ptr);
28 
29   if (sc_ptr)
30     m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
31 }
32 
33 SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
34   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
35                           rhs);
36 
37   m_opaque_up = clone(rhs.m_opaque_up);
38 }
39 
40 SBSymbolContext::~SBSymbolContext() = default;
41 
42 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
43   LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
44                      SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
45                      rhs);
46 
47   if (this != &rhs)
48     m_opaque_up = clone(rhs.m_opaque_up);
49   return LLDB_RECORD_RESULT(*this);
50 }
51 
52 void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
53   if (sc_ptr)
54     m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
55   else
56     m_opaque_up->Clear(true);
57 }
58 
59 bool SBSymbolContext::IsValid() const {
60   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
61   return this->operator bool();
62 }
63 SBSymbolContext::operator bool() const {
64   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
65 
66   return m_opaque_up != nullptr;
67 }
68 
69 SBModule SBSymbolContext::GetModule() {
70   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
71 
72   SBModule sb_module;
73   ModuleSP module_sp;
74   if (m_opaque_up) {
75     module_sp = m_opaque_up->module_sp;
76     sb_module.SetSP(module_sp);
77   }
78 
79   return LLDB_RECORD_RESULT(sb_module);
80 }
81 
82 SBCompileUnit SBSymbolContext::GetCompileUnit() {
83   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
84                              GetCompileUnit);
85 
86   return LLDB_RECORD_RESULT(
87       SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr));
88 }
89 
90 SBFunction SBSymbolContext::GetFunction() {
91   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
92 
93   Function *function = nullptr;
94 
95   if (m_opaque_up)
96     function = m_opaque_up->function;
97 
98   SBFunction sb_function(function);
99 
100   return LLDB_RECORD_RESULT(sb_function);
101 }
102 
103 SBBlock SBSymbolContext::GetBlock() {
104   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
105 
106   return LLDB_RECORD_RESULT(
107       SBBlock(m_opaque_up ? m_opaque_up->block : nullptr));
108 }
109 
110 SBLineEntry SBSymbolContext::GetLineEntry() {
111   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
112 
113   SBLineEntry sb_line_entry;
114   if (m_opaque_up)
115     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
116 
117   return LLDB_RECORD_RESULT(sb_line_entry);
118 }
119 
120 SBSymbol SBSymbolContext::GetSymbol() {
121   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
122 
123   Symbol *symbol = nullptr;
124 
125   if (m_opaque_up)
126     symbol = m_opaque_up->symbol;
127 
128   SBSymbol sb_symbol(symbol);
129 
130   return LLDB_RECORD_RESULT(sb_symbol);
131 }
132 
133 void SBSymbolContext::SetModule(lldb::SBModule module) {
134   LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
135                      module);
136 
137   ref().module_sp = module.GetSP();
138 }
139 
140 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
141   LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
142                      (lldb::SBCompileUnit), compile_unit);
143 
144   ref().comp_unit = compile_unit.get();
145 }
146 
147 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
148   LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
149                      function);
150 
151   ref().function = function.get();
152 }
153 
154 void SBSymbolContext::SetBlock(lldb::SBBlock block) {
155   LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
156 
157   ref().block = block.GetPtr();
158 }
159 
160 void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
161   LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
162                      line_entry);
163 
164   if (line_entry.IsValid())
165     ref().line_entry = line_entry.ref();
166   else
167     ref().line_entry.Clear();
168 }
169 
170 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
171   LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
172                      symbol);
173 
174   ref().symbol = symbol.get();
175 }
176 
177 lldb_private::SymbolContext *SBSymbolContext::operator->() const {
178   return m_opaque_up.get();
179 }
180 
181 const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
182   assert(m_opaque_up.get());
183   return *m_opaque_up;
184 }
185 
186 lldb_private::SymbolContext &SBSymbolContext::operator*() {
187   if (m_opaque_up == nullptr)
188     m_opaque_up = std::make_unique<SymbolContext>();
189   return *m_opaque_up;
190 }
191 
192 lldb_private::SymbolContext &SBSymbolContext::ref() {
193   if (m_opaque_up == nullptr)
194     m_opaque_up = std::make_unique<SymbolContext>();
195   return *m_opaque_up;
196 }
197 
198 lldb_private::SymbolContext *SBSymbolContext::get() const {
199   return m_opaque_up.get();
200 }
201 
202 bool SBSymbolContext::GetDescription(SBStream &description) {
203   LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
204                      description);
205 
206   Stream &strm = description.ref();
207 
208   if (m_opaque_up) {
209     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr);
210   } else
211     strm.PutCString("No value");
212 
213   return true;
214 }
215 
216 SBSymbolContext
217 SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
218                                          SBAddress &parent_frame_addr) const {
219   LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
220                            GetParentOfInlinedScope,
221                            (const lldb::SBAddress &, lldb::SBAddress &),
222                            curr_frame_pc, parent_frame_addr);
223 
224   SBSymbolContext sb_sc;
225   if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
226     if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
227                                              parent_frame_addr.ref()))
228       return LLDB_RECORD_RESULT(sb_sc);
229   }
230   return LLDB_RECORD_RESULT(SBSymbolContext());
231 }
232 
233 namespace lldb_private {
234 namespace repro {
235 
236 template <>
237 void RegisterMethods<SBSymbolContext>(Registry &R) {
238   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
239   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
240                             (const lldb_private::SymbolContext *));
241   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
242   LLDB_REGISTER_METHOD(
243       const lldb::SBSymbolContext &,
244       SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
245   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
246   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
247   LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
248   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
249                        ());
250   LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
251   LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
252   LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
253   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
254   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
255   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
256                        (lldb::SBCompileUnit));
257   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
258                        (lldb::SBFunction));
259   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
260   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
261                        (lldb::SBLineEntry));
262   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
263   LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
264                        (lldb::SBStream &));
265   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
266                              GetParentOfInlinedScope,
267                              (const lldb::SBAddress &, lldb::SBAddress &));
268 }
269 
270 }
271 }
272