1//===-- SBSymbol.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/SBSymbol.h"
10#include "SBReproducerPrivate.h"
11#include "lldb/API/SBStream.h"
12#include "lldb/Core/Disassembler.h"
13#include "lldb/Core/Module.h"
14#include "lldb/Symbol/Symbol.h"
15#include "lldb/Target/ExecutionContext.h"
16#include "lldb/Target/Target.h"
17
18using namespace lldb;
19using namespace lldb_private;
20
21SBSymbol::SBSymbol() : m_opaque_ptr(nullptr) {
22  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol);
23}
24
25SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr)
26    : m_opaque_ptr(lldb_object_ptr) {}
27
28SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
29  LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
30}
31
32const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
33  LLDB_RECORD_METHOD(const lldb::SBSymbol &,
34                     SBSymbol, operator=,(const lldb::SBSymbol &), rhs);
35
36  m_opaque_ptr = rhs.m_opaque_ptr;
37  return LLDB_RECORD_RESULT(*this);
38}
39
40SBSymbol::~SBSymbol() { m_opaque_ptr = nullptr; }
41
42void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
43  m_opaque_ptr = lldb_object_ptr;
44}
45
46bool SBSymbol::IsValid() const {
47  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid);
48  return this->operator bool();
49}
50SBSymbol::operator bool() const {
51  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool);
52
53  return m_opaque_ptr != nullptr;
54}
55
56const char *SBSymbol::GetName() const {
57  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
58
59  const char *name = nullptr;
60  if (m_opaque_ptr)
61    name = m_opaque_ptr->GetName().AsCString();
62
63  return name;
64}
65
66const char *SBSymbol::GetDisplayName() const {
67  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetDisplayName);
68
69  const char *name = nullptr;
70  if (m_opaque_ptr)
71    name = m_opaque_ptr->GetMangled()
72               .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
73               .AsCString();
74
75  return name;
76}
77
78const char *SBSymbol::GetMangledName() const {
79  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetMangledName);
80
81  const char *name = nullptr;
82  if (m_opaque_ptr)
83    name = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
84  return name;
85}
86
87bool SBSymbol::operator==(const SBSymbol &rhs) const {
88  LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator==,(const lldb::SBSymbol &),
89                           rhs);
90
91  return m_opaque_ptr == rhs.m_opaque_ptr;
92}
93
94bool SBSymbol::operator!=(const SBSymbol &rhs) const {
95  LLDB_RECORD_METHOD_CONST(bool, SBSymbol, operator!=,(const lldb::SBSymbol &),
96                           rhs);
97
98  return m_opaque_ptr != rhs.m_opaque_ptr;
99}
100
101bool SBSymbol::GetDescription(SBStream &description) {
102  LLDB_RECORD_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &),
103                     description);
104
105  Stream &strm = description.ref();
106
107  if (m_opaque_ptr) {
108    m_opaque_ptr->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr);
109  } else
110    strm.PutCString("No value");
111
112  return true;
113}
114
115SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
116  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
117                     (lldb::SBTarget), target);
118
119  return LLDB_RECORD_RESULT(GetInstructions(target, nullptr));
120}
121
122SBInstructionList SBSymbol::GetInstructions(SBTarget target,
123                                            const char *flavor_string) {
124  LLDB_RECORD_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
125                     (lldb::SBTarget, const char *), target, flavor_string);
126
127  SBInstructionList sb_instructions;
128  if (m_opaque_ptr) {
129    ExecutionContext exe_ctx;
130    TargetSP target_sp(target.GetSP());
131    std::unique_lock<std::recursive_mutex> lock;
132    if (target_sp) {
133      lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
134
135      target_sp->CalculateExecutionContext(exe_ctx);
136    }
137    if (m_opaque_ptr->ValueIsAddress()) {
138      const Address &symbol_addr = m_opaque_ptr->GetAddressRef();
139      ModuleSP module_sp = symbol_addr.GetModule();
140      if (module_sp) {
141        AddressRange symbol_range(symbol_addr, m_opaque_ptr->GetByteSize());
142        const bool prefer_file_cache = false;
143        sb_instructions.SetDisassembler(Disassembler::DisassembleRange(
144            module_sp->GetArchitecture(), nullptr, flavor_string, exe_ctx,
145            symbol_range, prefer_file_cache));
146      }
147    }
148  }
149  return LLDB_RECORD_RESULT(sb_instructions);
150}
151
152lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
153
154void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; }
155
156SBAddress SBSymbol::GetStartAddress() {
157  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetStartAddress);
158
159  SBAddress addr;
160  if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
161    addr.SetAddress(&m_opaque_ptr->GetAddressRef());
162  }
163  return LLDB_RECORD_RESULT(addr);
164}
165
166SBAddress SBSymbol::GetEndAddress() {
167  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBSymbol, GetEndAddress);
168
169  SBAddress addr;
170  if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
171    lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
172    if (range_size > 0) {
173      addr.SetAddress(&m_opaque_ptr->GetAddressRef());
174      addr->Slide(m_opaque_ptr->GetByteSize());
175    }
176  }
177  return LLDB_RECORD_RESULT(addr);
178}
179
180uint32_t SBSymbol::GetPrologueByteSize() {
181  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBSymbol, GetPrologueByteSize);
182
183  if (m_opaque_ptr)
184    return m_opaque_ptr->GetPrologueByteSize();
185  return 0;
186}
187
188SymbolType SBSymbol::GetType() {
189  LLDB_RECORD_METHOD_NO_ARGS(lldb::SymbolType, SBSymbol, GetType);
190
191  if (m_opaque_ptr)
192    return m_opaque_ptr->GetType();
193  return eSymbolTypeInvalid;
194}
195
196bool SBSymbol::IsExternal() {
197  LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsExternal);
198
199  if (m_opaque_ptr)
200    return m_opaque_ptr->IsExternal();
201  return false;
202}
203
204bool SBSymbol::IsSynthetic() {
205  LLDB_RECORD_METHOD_NO_ARGS(bool, SBSymbol, IsSynthetic);
206
207  if (m_opaque_ptr)
208    return m_opaque_ptr->IsSynthetic();
209  return false;
210}
211
212namespace lldb_private {
213namespace repro {
214
215template <>
216void RegisterMethods<SBSymbol>(Registry &R) {
217  LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
218  LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
219  LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
220                       SBSymbol, operator=,(const lldb::SBSymbol &));
221  LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
222  LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ());
223  LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
224  LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
225  LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
226  LLDB_REGISTER_METHOD_CONST(bool,
227                             SBSymbol, operator==,(const lldb::SBSymbol &));
228  LLDB_REGISTER_METHOD_CONST(bool,
229                             SBSymbol, operator!=,(const lldb::SBSymbol &));
230  LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));
231  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
232                       (lldb::SBTarget));
233  LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBSymbol, GetInstructions,
234                       (lldb::SBTarget, const char *));
235  LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetStartAddress, ());
236  LLDB_REGISTER_METHOD(lldb::SBAddress, SBSymbol, GetEndAddress, ());
237  LLDB_REGISTER_METHOD(uint32_t, SBSymbol, GetPrologueByteSize, ());
238  LLDB_REGISTER_METHOD(lldb::SymbolType, SBSymbol, GetType, ());
239  LLDB_REGISTER_METHOD(bool, SBSymbol, IsExternal, ());
240  LLDB_REGISTER_METHOD(bool, SBSymbol, IsSynthetic, ());
241}
242
243}
244}
245