1 //===-- SBSymbolContext.cpp -------------------------------------*- 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 #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 = llvm::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() {}
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 = llvm::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 != NULL;
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 : NULL));
88 }
89 
90 SBFunction SBSymbolContext::GetFunction() {
91   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
92 
93   Function *function = NULL;
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(SBBlock(m_opaque_up ? m_opaque_up->block : NULL));
107 }
108 
109 SBLineEntry SBSymbolContext::GetLineEntry() {
110   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
111 
112   SBLineEntry sb_line_entry;
113   if (m_opaque_up)
114     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
115 
116   return LLDB_RECORD_RESULT(sb_line_entry);
117 }
118 
119 SBSymbol SBSymbolContext::GetSymbol() {
120   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
121 
122   Symbol *symbol = NULL;
123 
124   if (m_opaque_up)
125     symbol = m_opaque_up->symbol;
126 
127   SBSymbol sb_symbol(symbol);
128 
129   return LLDB_RECORD_RESULT(sb_symbol);
130 }
131 
132 void SBSymbolContext::SetModule(lldb::SBModule module) {
133   LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
134                      module);
135 
136   ref().module_sp = module.GetSP();
137 }
138 
139 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
140   LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
141                      (lldb::SBCompileUnit), compile_unit);
142 
143   ref().comp_unit = compile_unit.get();
144 }
145 
146 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
147   LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
148                      function);
149 
150   ref().function = function.get();
151 }
152 
153 void SBSymbolContext::SetBlock(lldb::SBBlock block) {
154   LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
155 
156   ref().block = block.GetPtr();
157 }
158 
159 void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
160   LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
161                      line_entry);
162 
163   if (line_entry.IsValid())
164     ref().line_entry = line_entry.ref();
165   else
166     ref().line_entry.Clear();
167 }
168 
169 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
170   LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
171                      symbol);
172 
173   ref().symbol = symbol.get();
174 }
175 
176 lldb_private::SymbolContext *SBSymbolContext::operator->() const {
177   return m_opaque_up.get();
178 }
179 
180 const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
181   assert(m_opaque_up.get());
182   return *m_opaque_up;
183 }
184 
185 lldb_private::SymbolContext &SBSymbolContext::operator*() {
186   if (m_opaque_up == NULL)
187     m_opaque_up.reset(new SymbolContext);
188   return *m_opaque_up;
189 }
190 
191 lldb_private::SymbolContext &SBSymbolContext::ref() {
192   if (m_opaque_up == NULL)
193     m_opaque_up.reset(new SymbolContext);
194   return *m_opaque_up;
195 }
196 
197 lldb_private::SymbolContext *SBSymbolContext::get() const {
198   return m_opaque_up.get();
199 }
200 
201 bool SBSymbolContext::GetDescription(SBStream &description) {
202   LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
203                      description);
204 
205   Stream &strm = description.ref();
206 
207   if (m_opaque_up) {
208     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL);
209   } else
210     strm.PutCString("No value");
211 
212   return true;
213 }
214 
215 SBSymbolContext
216 SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
217                                          SBAddress &parent_frame_addr) const {
218   LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
219                            GetParentOfInlinedScope,
220                            (const lldb::SBAddress &, lldb::SBAddress &),
221                            curr_frame_pc, parent_frame_addr);
222 
223   SBSymbolContext sb_sc;
224   if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
225     if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
226                                              parent_frame_addr.ref()))
227       return LLDB_RECORD_RESULT(sb_sc);
228   }
229   return LLDB_RECORD_RESULT(SBSymbolContext());
230 }
231 
232 namespace lldb_private {
233 namespace repro {
234 
235 template <>
236 void RegisterMethods<SBSymbolContext>(Registry &R) {
237   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
238   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
239                             (const lldb_private::SymbolContext *));
240   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
241   LLDB_REGISTER_METHOD(
242       const lldb::SBSymbolContext &,
243       SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
244   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
245   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
246   LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
247   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
248                        ());
249   LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
250   LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
251   LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
252   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
253   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
254   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
255                        (lldb::SBCompileUnit));
256   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
257                        (lldb::SBFunction));
258   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
259   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
260                        (lldb::SBLineEntry));
261   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
262   LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
263                        (lldb::SBStream &));
264   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
265                              GetParentOfInlinedScope,
266                              (const lldb::SBAddress &, lldb::SBAddress &));
267 }
268 
269 }
270 }
271