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

source code of lldb/source/API/SBSymbol.cpp