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
18using namespace lldb;
19using namespace lldb_private;
20
21SBSymbolContext::SBSymbolContext() : m_opaque_up() {
22  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
23}
24
25SBSymbolContext::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
33SBSymbolContext::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
40SBSymbolContext::~SBSymbolContext() {}
41
42const 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
52void 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
59bool SBSymbolContext::IsValid() const {
60  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
61  return this->operator bool();
62}
63SBSymbolContext::operator bool() const {
64  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
65
66  return m_opaque_up != nullptr;
67}
68
69SBModule 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
82SBCompileUnit 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
90SBFunction 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
103SBBlock 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
110SBLineEntry 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
120SBSymbol 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
133void 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
140void 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
147void SBSymbolContext::SetFunction(lldb::SBFunction function) {
148  LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
149                     function);
150
151  ref().function = function.get();
152}
153
154void SBSymbolContext::SetBlock(lldb::SBBlock block) {
155  LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
156
157  ref().block = block.GetPtr();
158}
159
160void 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
170void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
171  LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
172                     symbol);
173
174  ref().symbol = symbol.get();
175}
176
177lldb_private::SymbolContext *SBSymbolContext::operator->() const {
178  return m_opaque_up.get();
179}
180
181const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
182  assert(m_opaque_up.get());
183  return *m_opaque_up;
184}
185
186lldb_private::SymbolContext &SBSymbolContext::operator*() {
187  if (m_opaque_up == nullptr)
188    m_opaque_up.reset(new SymbolContext);
189  return *m_opaque_up;
190}
191
192lldb_private::SymbolContext &SBSymbolContext::ref() {
193  if (m_opaque_up == nullptr)
194    m_opaque_up.reset(new SymbolContext);
195  return *m_opaque_up;
196}
197
198lldb_private::SymbolContext *SBSymbolContext::get() const {
199  return m_opaque_up.get();
200}
201
202bool 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
216SBSymbolContext
217SBSymbolContext::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
233namespace lldb_private {
234namespace repro {
235
236template <>
237void 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