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,
130 cpu: target_sp->GetDisassemblyCPU(), features: target_sp->GetDisassemblyFeatures(),
131 target&: *target_sp, disasm_ranges: symbol_range, force_live_memory));
132 }
133 }
134 }
135 return sb_instructions;
136}
137
138lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
139
140void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; }
141
142SBAddress SBSymbol::GetStartAddress() {
143 LLDB_INSTRUMENT_VA(this);
144
145 SBAddress addr;
146 if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
147 addr.SetAddress(m_opaque_ptr->GetAddressRef());
148 }
149 return addr;
150}
151
152SBAddress SBSymbol::GetEndAddress() {
153 LLDB_INSTRUMENT_VA(this);
154
155 SBAddress addr;
156 if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
157 lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
158 if (range_size > 0) {
159 addr.SetAddress(m_opaque_ptr->GetAddressRef());
160 addr->Slide(offset: m_opaque_ptr->GetByteSize());
161 }
162 }
163 return addr;
164}
165
166uint64_t SBSymbol::GetValue() {
167 LLDB_INSTRUMENT_VA(this);
168 if (m_opaque_ptr)
169 return m_opaque_ptr->GetRawValue();
170 return 0;
171}
172
173uint64_t SBSymbol::GetSize() {
174 LLDB_INSTRUMENT_VA(this);
175 if (m_opaque_ptr && m_opaque_ptr->GetByteSizeIsValid())
176 return m_opaque_ptr->GetByteSize();
177 return 0;
178}
179
180uint32_t SBSymbol::GetPrologueByteSize() {
181 LLDB_INSTRUMENT_VA(this);
182
183 if (m_opaque_ptr)
184 return m_opaque_ptr->GetPrologueByteSize();
185 return 0;
186}
187
188SymbolType SBSymbol::GetType() {
189 LLDB_INSTRUMENT_VA(this);
190
191 if (m_opaque_ptr)
192 return m_opaque_ptr->GetType();
193 return eSymbolTypeInvalid;
194}
195
196bool SBSymbol::IsExternal() {
197 LLDB_INSTRUMENT_VA(this);
198
199 if (m_opaque_ptr)
200 return m_opaque_ptr->IsExternal();
201 return false;
202}
203
204bool SBSymbol::IsSynthetic() {
205 LLDB_INSTRUMENT_VA(this);
206
207 if (m_opaque_ptr)
208 return m_opaque_ptr->IsSynthetic();
209 return false;
210}
211

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