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 "lldb/Utility/ReproducerInstrumentation.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() {
22   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
23 }
24 
25 SBSymbolContext::SBSymbolContext(const SymbolContext &sc)
26     : m_opaque_up(std::make_unique<SymbolContext>(sc)) {
27   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
28                           (const lldb_private::SymbolContext &), sc);
29 }
30 
31 SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) {
32   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
33                           rhs);
34 
35   m_opaque_up = clone(rhs.m_opaque_up);
36 }
37 
38 SBSymbolContext::~SBSymbolContext() = default;
39 
40 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
41   LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
42                      SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
43                      rhs);
44 
45   if (this != &rhs)
46     m_opaque_up = clone(rhs.m_opaque_up);
47   return *this;
48 }
49 
50 bool SBSymbolContext::IsValid() const {
51   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
52   return this->operator bool();
53 }
54 SBSymbolContext::operator bool() const {
55   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
56 
57   return m_opaque_up != nullptr;
58 }
59 
60 SBModule SBSymbolContext::GetModule() {
61   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
62 
63   SBModule sb_module;
64   ModuleSP module_sp;
65   if (m_opaque_up) {
66     module_sp = m_opaque_up->module_sp;
67     sb_module.SetSP(module_sp);
68   }
69 
70   return sb_module;
71 }
72 
73 SBCompileUnit SBSymbolContext::GetCompileUnit() {
74   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
75                              GetCompileUnit);
76 
77   return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr);
78 }
79 
80 SBFunction SBSymbolContext::GetFunction() {
81   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
82 
83   Function *function = nullptr;
84 
85   if (m_opaque_up)
86     function = m_opaque_up->function;
87 
88   SBFunction sb_function(function);
89 
90   return sb_function;
91 }
92 
93 SBBlock SBSymbolContext::GetBlock() {
94   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
95 
96   return SBBlock(m_opaque_up ? m_opaque_up->block : nullptr);
97 }
98 
99 SBLineEntry SBSymbolContext::GetLineEntry() {
100   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
101 
102   SBLineEntry sb_line_entry;
103   if (m_opaque_up)
104     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
105 
106   return sb_line_entry;
107 }
108 
109 SBSymbol SBSymbolContext::GetSymbol() {
110   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
111 
112   Symbol *symbol = nullptr;
113 
114   if (m_opaque_up)
115     symbol = m_opaque_up->symbol;
116 
117   SBSymbol sb_symbol(symbol);
118 
119   return sb_symbol;
120 }
121 
122 void SBSymbolContext::SetModule(lldb::SBModule module) {
123   LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
124                      module);
125 
126   ref().module_sp = module.GetSP();
127 }
128 
129 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
130   LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
131                      (lldb::SBCompileUnit), compile_unit);
132 
133   ref().comp_unit = compile_unit.get();
134 }
135 
136 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
137   LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
138                      function);
139 
140   ref().function = function.get();
141 }
142 
143 void SBSymbolContext::SetBlock(lldb::SBBlock block) {
144   LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
145 
146   ref().block = block.GetPtr();
147 }
148 
149 void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
150   LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
151                      line_entry);
152 
153   if (line_entry.IsValid())
154     ref().line_entry = line_entry.ref();
155   else
156     ref().line_entry.Clear();
157 }
158 
159 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
160   LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
161                      symbol);
162 
163   ref().symbol = symbol.get();
164 }
165 
166 lldb_private::SymbolContext *SBSymbolContext::operator->() const {
167   return m_opaque_up.get();
168 }
169 
170 const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
171   assert(m_opaque_up.get());
172   return *m_opaque_up;
173 }
174 
175 lldb_private::SymbolContext &SBSymbolContext::operator*() {
176   if (m_opaque_up == nullptr)
177     m_opaque_up = std::make_unique<SymbolContext>();
178   return *m_opaque_up;
179 }
180 
181 lldb_private::SymbolContext &SBSymbolContext::ref() {
182   if (m_opaque_up == nullptr)
183     m_opaque_up = std::make_unique<SymbolContext>();
184   return *m_opaque_up;
185 }
186 
187 lldb_private::SymbolContext *SBSymbolContext::get() const {
188   return m_opaque_up.get();
189 }
190 
191 bool SBSymbolContext::GetDescription(SBStream &description) {
192   LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
193                      description);
194 
195   Stream &strm = description.ref();
196 
197   if (m_opaque_up) {
198     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr);
199   } else
200     strm.PutCString("No value");
201 
202   return true;
203 }
204 
205 SBSymbolContext
206 SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
207                                          SBAddress &parent_frame_addr) const {
208   LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
209                            GetParentOfInlinedScope,
210                            (const lldb::SBAddress &, lldb::SBAddress &),
211                            curr_frame_pc, parent_frame_addr);
212 
213   SBSymbolContext sb_sc;
214   if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
215     if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
216                                              parent_frame_addr.ref()))
217       return sb_sc;
218   }
219   return SBSymbolContext();
220 }
221