LLDB mainline
SBSymbol.cpp
Go to the documentation of this file.
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"
12#include "lldb/Core/Module.h"
13#include "lldb/Symbol/Symbol.h"
15#include "lldb/Target/Target.h"
17
18using namespace lldb;
19using namespace lldb_private;
20
22
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
31 LLDB_INSTRUMENT_VA(this, rhs);
32
34 return *this;
35}
36
38
40 m_opaque_ptr = lldb_object_ptr;
41}
42
43bool SBSymbol::IsValid() const {
45 return this->operator bool();
46}
47SBSymbol::operator bool() const {
49
50 return m_opaque_ptr != nullptr;
51}
52
53const char *SBSymbol::GetName() const {
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 {
65
66 const char *name = nullptr;
67 if (m_opaque_ptr)
69
70 return name;
71}
72
73const char *SBSymbol::GetMangledName() const {
75
76 const char *name = nullptr;
77 if (m_opaque_ptr)
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
95 LLDB_INSTRUMENT_VA(this, description);
96
97 Stream &strm = description.ref();
98
99 if (m_opaque_ptr) {
101 } else
102 strm.PutCString("No value");
103
104 return true;
105}
106
108 LLDB_INSTRUMENT_VA(this, target);
109
110 return GetInstructions(target, nullptr);
111}
112
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;
129 module_sp->GetArchitecture(), nullptr, flavor_string, *target_sp,
130 symbol_range, force_live_memory));
131 }
132 }
133 }
134 return sb_instructions;
135}
136
138
140
142 LLDB_INSTRUMENT_VA(this);
143
144 SBAddress addr;
147 }
148 return addr;
149}
150
152 LLDB_INSTRUMENT_VA(this);
153
154 SBAddress addr;
156 lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
157 if (range_size > 0) {
160 }
161 }
162 return addr;
163}
164
166 LLDB_INSTRUMENT_VA(this);
167 if (m_opaque_ptr)
168 return m_opaque_ptr->GetRawValue();
169 return 0;
170}
171
173 LLDB_INSTRUMENT_VA(this);
175 return m_opaque_ptr->GetByteSize();
176 return 0;
177}
178
180 LLDB_INSTRUMENT_VA(this);
181
182 if (m_opaque_ptr)
184 return 0;
185}
186
188 LLDB_INSTRUMENT_VA(this);
189
190 if (m_opaque_ptr)
191 return m_opaque_ptr->GetType();
192 return eSymbolTypeInvalid;
193}
194
196 LLDB_INSTRUMENT_VA(this);
197
198 if (m_opaque_ptr)
199 return m_opaque_ptr->IsExternal();
200 return false;
201}
202
204 LLDB_INSTRUMENT_VA(this);
205
206 if (m_opaque_ptr)
207 return m_opaque_ptr->IsSynthetic();
208 return false;
209}
#define LLDB_INSTRUMENT_VA(...)
void SetAddress(lldb::SBSection section, lldb::addr_t offset)
Definition: SBAddress.cpp:88
void SetDisassembler(const lldb::DisassemblerSP &opaque_sp)
lldb_private::Stream & ref()
Definition: SBStream.cpp:177
uint64_t GetValue()
Get the raw value of a symbol.
Definition: SBSymbol.cpp:165
SymbolType GetType()
Definition: SBSymbol.cpp:187
const char * GetDisplayName() const
Definition: SBSymbol.cpp:63
const char * GetMangledName() const
Definition: SBSymbol.cpp:73
uint32_t GetPrologueByteSize()
Definition: SBSymbol.cpp:179
bool IsSynthetic()
Definition: SBSymbol.cpp:203
void reset(lldb_private::Symbol *)
Definition: SBSymbol.cpp:139
bool GetDescription(lldb::SBStream &description)
Definition: SBSymbol.cpp:94
SBAddress GetStartAddress()
Get the start address of this symbol.
Definition: SBSymbol.cpp:141
SBAddress GetEndAddress()
Get the end address of this symbol.
Definition: SBSymbol.cpp:151
bool operator==(const lldb::SBSymbol &rhs) const
Definition: SBSymbol.cpp:82
lldb_private::Symbol * m_opaque_ptr
Definition: SBSymbol.h:117
bool IsValid() const
Definition: SBSymbol.cpp:43
const lldb::SBSymbol & operator=(const lldb::SBSymbol &rhs)
Definition: SBSymbol.cpp:30
const char * GetName() const
Definition: SBSymbol.cpp:53
uint64_t GetSize()
Get the size of the symbol.
Definition: SBSymbol.cpp:172
void SetSymbol(lldb_private::Symbol *lldb_object_ptr)
Definition: SBSymbol.cpp:39
lldb::SBInstructionList GetInstructions(lldb::SBTarget target)
Definition: SBSymbol.cpp:107
bool IsExternal()
Definition: SBSymbol.cpp:195
bool operator!=(const lldb::SBSymbol &rhs) const
Definition: SBSymbol.cpp:88
lldb_private::Symbol * get()
Definition: SBSymbol.cpp:137
lldb::TargetSP GetSP() const
Definition: SBTarget.cpp:585
A section + offset based address range class.
Definition: AddressRange.h:25
A section + offset based address class.
Definition: Address.h:62
bool Slide(int64_t offset)
Definition: Address.h:459
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:285
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch, const char *plugin_name, const char *flavor, Target &target, const AddressRange &disasm_range, bool force_live_memory=false)
ConstString & GetMangledName()
Mangled name get accessor.
Definition: Mangled.h:145
ConstString GetDisplayDemangledName() const
Display demangled name get accessor.
Definition: Mangled.cpp:310
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:65
bool ValueIsAddress() const
Definition: Symbol.cpp:169
bool IsExternal() const
Definition: Symbol.h:196
bool IsSynthetic() const
Definition: Symbol.h:182
bool GetByteSizeIsValid() const
Definition: Symbol.h:208
Mangled & GetMangled()
Definition: Symbol.h:146
Address & GetAddressRef()
Definition: Symbol.h:72
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target, std::optional< Stream::HighlightSettings > settings=std::nullopt) const
Definition: Symbol.cpp:229
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:472
ConstString GetName() const
Definition: Symbol.cpp:552
lldb::SymbolType GetType() const
Definition: Symbol.h:168
uint32_t GetPrologueByteSize()
Definition: Symbol.cpp:317
uint64_t GetRawValue() const
Get the raw value of the symbol from the symbol table.
Definition: Symbol.h:109
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
@ eDescriptionLevelFull
SymbolType
Symbol types.
@ eSymbolTypeInvalid
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:436
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365