1 //===-- SBSymbol.cpp --------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/API/SBSymbol.h"
11 #include "lldb/API/SBStream.h"
12 #include "lldb/Core/Disassembler.h"
13 #include "lldb/Core/Log.h"
14 #include "lldb/Core/Module.h"
15 #include "lldb/Symbol/Symbol.h"
16 #include "lldb/Target/ExecutionContext.h"
17 #include "lldb/Target/Target.h"
18
19 using namespace lldb;
20 using namespace lldb_private;
21
SBSymbol()22 SBSymbol::SBSymbol () :
23 m_opaque_ptr (NULL)
24 {
25 }
26
SBSymbol(lldb_private::Symbol * lldb_object_ptr)27 SBSymbol::SBSymbol (lldb_private::Symbol *lldb_object_ptr) :
28 m_opaque_ptr (lldb_object_ptr)
29 {
30 }
31
SBSymbol(const lldb::SBSymbol & rhs)32 SBSymbol::SBSymbol (const lldb::SBSymbol &rhs) :
33 m_opaque_ptr (rhs.m_opaque_ptr)
34 {
35 }
36
37 const SBSymbol &
operator =(const SBSymbol & rhs)38 SBSymbol::operator = (const SBSymbol &rhs)
39 {
40 m_opaque_ptr = rhs.m_opaque_ptr;
41 return *this;
42 }
43
~SBSymbol()44 SBSymbol::~SBSymbol ()
45 {
46 m_opaque_ptr = NULL;
47 }
48
49 void
SetSymbol(lldb_private::Symbol * lldb_object_ptr)50 SBSymbol::SetSymbol (lldb_private::Symbol *lldb_object_ptr)
51 {
52 m_opaque_ptr = lldb_object_ptr;
53 }
54
55 bool
IsValid() const56 SBSymbol::IsValid () const
57 {
58 return m_opaque_ptr != NULL;
59 }
60
61 const char *
GetName() const62 SBSymbol::GetName() const
63 {
64 const char *name = NULL;
65 if (m_opaque_ptr)
66 name = m_opaque_ptr->GetMangled().GetName().AsCString();
67
68 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
69 if (log)
70 log->Printf ("SBSymbol(%p)::GetName () => \"%s\"", m_opaque_ptr, name ? name : "");
71 return name;
72 }
73
74 const char *
GetMangledName() const75 SBSymbol::GetMangledName () const
76 {
77 const char *name = NULL;
78 if (m_opaque_ptr)
79 name = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
80 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
81 if (log)
82 log->Printf ("SBSymbol(%p)::GetMangledName () => \"%s\"", m_opaque_ptr, name ? name : "");
83
84 return name;
85 }
86
87
88 bool
operator ==(const SBSymbol & rhs) const89 SBSymbol::operator == (const SBSymbol &rhs) const
90 {
91 return m_opaque_ptr == rhs.m_opaque_ptr;
92 }
93
94 bool
operator !=(const SBSymbol & rhs) const95 SBSymbol::operator != (const SBSymbol &rhs) const
96 {
97 return m_opaque_ptr != rhs.m_opaque_ptr;
98 }
99
100 bool
GetDescription(SBStream & description)101 SBSymbol::GetDescription (SBStream &description)
102 {
103 Stream &strm = description.ref();
104
105 if (m_opaque_ptr)
106 {
107 m_opaque_ptr->GetDescription (&strm,
108 lldb::eDescriptionLevelFull, NULL);
109 }
110 else
111 strm.PutCString ("No value");
112
113 return true;
114 }
115
116 SBInstructionList
GetInstructions(SBTarget target)117 SBSymbol::GetInstructions (SBTarget target)
118 {
119 return GetInstructions (target, NULL);
120 }
121
122 SBInstructionList
GetInstructions(SBTarget target,const char * flavor_string)123 SBSymbol::GetInstructions (SBTarget target, const char *flavor_string)
124 {
125 SBInstructionList sb_instructions;
126 if (m_opaque_ptr)
127 {
128 Mutex::Locker api_locker;
129 ExecutionContext exe_ctx;
130 TargetSP target_sp (target.GetSP());
131 if (target_sp)
132 {
133 api_locker.Lock (target_sp->GetAPIMutex());
134 target_sp->CalculateExecutionContext (exe_ctx);
135 }
136 if (m_opaque_ptr->ValueIsAddress())
137 {
138 ModuleSP module_sp (m_opaque_ptr->GetAddress().GetModule());
139 if (module_sp)
140 {
141 AddressRange symbol_range (m_opaque_ptr->GetAddress(), m_opaque_ptr->GetByteSize());
142 sb_instructions.SetDisassembler (Disassembler::DisassembleRange (module_sp->GetArchitecture (),
143 NULL,
144 flavor_string,
145 exe_ctx,
146 symbol_range));
147 }
148 }
149 }
150 return sb_instructions;
151 }
152
153 lldb_private::Symbol *
get()154 SBSymbol::get ()
155 {
156 return m_opaque_ptr;
157 }
158
159 void
reset(lldb_private::Symbol * symbol)160 SBSymbol::reset (lldb_private::Symbol *symbol)
161 {
162 m_opaque_ptr = symbol;
163 }
164
165 SBAddress
GetStartAddress()166 SBSymbol::GetStartAddress ()
167 {
168 SBAddress addr;
169 if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress())
170 {
171 addr.SetAddress (&m_opaque_ptr->GetAddress());
172 }
173 return addr;
174 }
175
176 SBAddress
GetEndAddress()177 SBSymbol::GetEndAddress ()
178 {
179 SBAddress addr;
180 if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress())
181 {
182 lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
183 if (range_size > 0)
184 {
185 addr.SetAddress (&m_opaque_ptr->GetAddress());
186 addr->Slide (m_opaque_ptr->GetByteSize());
187 }
188 }
189 return addr;
190 }
191
192 uint32_t
GetPrologueByteSize()193 SBSymbol::GetPrologueByteSize ()
194 {
195 if (m_opaque_ptr)
196 return m_opaque_ptr->GetPrologueByteSize();
197 return 0;
198 }
199
200 SymbolType
GetType()201 SBSymbol::GetType ()
202 {
203 if (m_opaque_ptr)
204 return m_opaque_ptr->GetType();
205 return eSymbolTypeInvalid;
206 }
207
208 bool
IsExternal()209 SBSymbol::IsExternal()
210 {
211 if (m_opaque_ptr)
212 return m_opaque_ptr->IsExternal();
213 return false;
214 }
215
216 bool
IsSynthetic()217 SBSymbol::IsSynthetic()
218 {
219 if (m_opaque_ptr)
220 return m_opaque_ptr->IsSynthetic();
221 return false;
222 }
223
224