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 const bool prefer_file_cache = false;
143 sb_instructions.SetDisassembler (Disassembler::DisassembleRange (module_sp->GetArchitecture (),
144 NULL,
145 flavor_string,
146 exe_ctx,
147 symbol_range,
148 prefer_file_cache));
149 }
150 }
151 }
152 return sb_instructions;
153 }
154
155 lldb_private::Symbol *
get()156 SBSymbol::get ()
157 {
158 return m_opaque_ptr;
159 }
160
161 void
reset(lldb_private::Symbol * symbol)162 SBSymbol::reset (lldb_private::Symbol *symbol)
163 {
164 m_opaque_ptr = symbol;
165 }
166
167 SBAddress
GetStartAddress()168 SBSymbol::GetStartAddress ()
169 {
170 SBAddress addr;
171 if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress())
172 {
173 addr.SetAddress (&m_opaque_ptr->GetAddress());
174 }
175 return addr;
176 }
177
178 SBAddress
GetEndAddress()179 SBSymbol::GetEndAddress ()
180 {
181 SBAddress addr;
182 if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress())
183 {
184 lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
185 if (range_size > 0)
186 {
187 addr.SetAddress (&m_opaque_ptr->GetAddress());
188 addr->Slide (m_opaque_ptr->GetByteSize());
189 }
190 }
191 return addr;
192 }
193
194 uint32_t
GetPrologueByteSize()195 SBSymbol::GetPrologueByteSize ()
196 {
197 if (m_opaque_ptr)
198 return m_opaque_ptr->GetPrologueByteSize();
199 return 0;
200 }
201
202 SymbolType
GetType()203 SBSymbol::GetType ()
204 {
205 if (m_opaque_ptr)
206 return m_opaque_ptr->GetType();
207 return eSymbolTypeInvalid;
208 }
209
210 bool
IsExternal()211 SBSymbol::IsExternal()
212 {
213 if (m_opaque_ptr)
214 return m_opaque_ptr->IsExternal();
215 return false;
216 }
217
218 bool
IsSynthetic()219 SBSymbol::IsSynthetic()
220 {
221 if (m_opaque_ptr)
222 return m_opaque_ptr->IsSynthetic();
223 return false;
224 }
225
226