1 //===-- SBAddress.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/SBAddress.h"
11 #include "lldb/API/SBProcess.h"
12 #include "lldb/API/SBSection.h"
13 #include "lldb/API/SBStream.h"
14 #include "lldb/Core/Address.h"
15 #include "lldb/Core/Log.h"
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/StreamString.h"
18 #include "lldb/Host/Mutex.h"
19 #include "lldb/Symbol/LineEntry.h"
20 #include "lldb/Target/Target.h"
21 
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 
27 SBAddress::SBAddress () :
28     m_opaque_ap (new Address())
29 {
30 }
31 
32 SBAddress::SBAddress (const Address *lldb_object_ptr) :
33     m_opaque_ap (new Address())
34 {
35     if (lldb_object_ptr)
36         ref() = *lldb_object_ptr;
37 }
38 
39 SBAddress::SBAddress (const SBAddress &rhs) :
40     m_opaque_ap (new Address())
41 {
42     if (rhs.IsValid())
43         ref() = rhs.ref();
44 }
45 
46 
47 SBAddress::SBAddress (lldb::SBSection section, lldb::addr_t offset) :
48     m_opaque_ap(new Address (section.GetSP(), offset))
49 {
50 }
51 
52 // Create an address by resolving a load address using the supplied target
53 SBAddress::SBAddress (lldb::addr_t load_addr, lldb::SBTarget &target) :
54     m_opaque_ap(new Address())
55 {
56     SetLoadAddress (load_addr, target);
57 }
58 
59 
60 
61 SBAddress::~SBAddress ()
62 {
63 }
64 
65 const SBAddress &
66 SBAddress::operator = (const SBAddress &rhs)
67 {
68     if (this != &rhs)
69     {
70         if (rhs.IsValid())
71             ref() = rhs.ref();
72         else
73             m_opaque_ap.reset (new Address());
74     }
75     return *this;
76 }
77 
78 bool
79 SBAddress::IsValid () const
80 {
81     return m_opaque_ap.get() != NULL && m_opaque_ap->IsValid();
82 }
83 
84 void
85 SBAddress::Clear ()
86 {
87     m_opaque_ap.reset (new Address());
88 }
89 
90 void
91 SBAddress::SetAddress (lldb::SBSection section, lldb::addr_t offset)
92 {
93     Address &addr = ref();
94     addr.SetSection (section.GetSP());
95     addr.SetOffset (offset);
96 }
97 
98 
99 void
100 SBAddress::SetAddress (const Address *lldb_object_ptr)
101 {
102     if (lldb_object_ptr)
103         ref() =  *lldb_object_ptr;
104     else
105         m_opaque_ap.reset (new Address());
106 }
107 
108 lldb::addr_t
109 SBAddress::GetFileAddress () const
110 {
111     if (m_opaque_ap->IsValid())
112         return m_opaque_ap->GetFileAddress();
113     else
114         return LLDB_INVALID_ADDRESS;
115 }
116 
117 lldb::addr_t
118 SBAddress::GetLoadAddress (const SBTarget &target) const
119 {
120     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
121 
122     lldb::addr_t addr = LLDB_INVALID_ADDRESS;
123     TargetSP target_sp (target.GetSP());
124     if (target_sp)
125     {
126         if (m_opaque_ap->IsValid())
127         {
128             Mutex::Locker api_locker (target_sp->GetAPIMutex());
129             addr = m_opaque_ap->GetLoadAddress (target_sp.get());
130         }
131     }
132 
133     if (log)
134     {
135         if (addr == LLDB_INVALID_ADDRESS)
136             log->Printf ("SBAddress::GetLoadAddress (SBTarget(%p)) => LLDB_INVALID_ADDRESS",
137                          static_cast<void*>(target_sp.get()));
138         else
139             log->Printf ("SBAddress::GetLoadAddress (SBTarget(%p)) => 0x%" PRIx64,
140                          static_cast<void*>(target_sp.get()), addr);
141     }
142 
143     return addr;
144 }
145 
146 void
147 SBAddress::SetLoadAddress (lldb::addr_t load_addr, lldb::SBTarget &target)
148 {
149     // Create the address object if we don't already have one
150     ref();
151     if (target.IsValid())
152         *this = target.ResolveLoadAddress(load_addr);
153     else
154         m_opaque_ap->Clear();
155 
156     // Check if we weren't were able to resolve a section offset address.
157     // If we weren't it is ok, the load address might be a location on the
158     // stack or heap, so we should just have an address with no section and
159     // a valid offset
160     if (!m_opaque_ap->IsValid())
161         m_opaque_ap->SetOffset(load_addr);
162 }
163 
164 bool
165 SBAddress::OffsetAddress (addr_t offset)
166 {
167     if (m_opaque_ap->IsValid())
168     {
169         addr_t addr_offset = m_opaque_ap->GetOffset();
170         if (addr_offset != LLDB_INVALID_ADDRESS)
171         {
172             m_opaque_ap->SetOffset(addr_offset + offset);
173             return true;
174         }
175     }
176     return false;
177 }
178 
179 lldb::SBSection
180 SBAddress::GetSection ()
181 {
182     lldb::SBSection sb_section;
183     if (m_opaque_ap->IsValid())
184         sb_section.SetSP (m_opaque_ap->GetSection());
185     return sb_section;
186 }
187 
188 lldb::addr_t
189 SBAddress::GetOffset ()
190 {
191     if (m_opaque_ap->IsValid())
192         return m_opaque_ap->GetOffset();
193     return 0;
194 }
195 
196 Address *
197 SBAddress::operator->()
198 {
199     return m_opaque_ap.get();
200 }
201 
202 const Address *
203 SBAddress::operator->() const
204 {
205     return m_opaque_ap.get();
206 }
207 
208 Address &
209 SBAddress::ref ()
210 {
211     if (m_opaque_ap.get() == NULL)
212         m_opaque_ap.reset (new Address());
213     return *m_opaque_ap;
214 }
215 
216 const Address &
217 SBAddress::ref () const
218 {
219     // This object should already have checked with "IsValid()"
220     // prior to calling this function. In case you didn't we will assert
221     // and die to let you know.
222     assert (m_opaque_ap.get());
223     return *m_opaque_ap;
224 }
225 
226 Address *
227 SBAddress::get ()
228 {
229     return m_opaque_ap.get();
230 }
231 
232 bool
233 SBAddress::GetDescription (SBStream &description)
234 {
235     // Call "ref()" on the stream to make sure it creates a backing stream in
236     // case there isn't one already...
237     Stream &strm = description.ref();
238     if (m_opaque_ap->IsValid())
239     {
240         m_opaque_ap->Dump (&strm,
241                            NULL,
242                            Address::DumpStyleResolvedDescription,
243                            Address::DumpStyleModuleWithFileAddress,
244                            4);
245         StreamString sstrm;
246 //        m_opaque_ap->Dump (&sstrm, NULL, Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid, 4);
247 //        if (sstrm.GetData())
248 //            strm.Printf (" (%s)", sstrm.GetData());
249     }
250     else
251         strm.PutCString ("No value");
252 
253     return true;
254 }
255 
256 SBModule
257 SBAddress::GetModule ()
258 {
259     SBModule sb_module;
260     if (m_opaque_ap->IsValid())
261         sb_module.SetSP (m_opaque_ap->GetModule());
262     return sb_module;
263 }
264 
265 SBSymbolContext
266 SBAddress::GetSymbolContext (uint32_t resolve_scope)
267 {
268     SBSymbolContext sb_sc;
269     if (m_opaque_ap->IsValid())
270         m_opaque_ap->CalculateSymbolContext (&sb_sc.ref(), resolve_scope);
271     return sb_sc;
272 }
273 
274 SBCompileUnit
275 SBAddress::GetCompileUnit ()
276 {
277     SBCompileUnit sb_comp_unit;
278     if (m_opaque_ap->IsValid())
279         sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit());
280     return sb_comp_unit;
281 }
282 
283 SBFunction
284 SBAddress::GetFunction ()
285 {
286     SBFunction sb_function;
287     if (m_opaque_ap->IsValid())
288         sb_function.reset(m_opaque_ap->CalculateSymbolContextFunction());
289     return sb_function;
290 }
291 
292 SBBlock
293 SBAddress::GetBlock ()
294 {
295     SBBlock sb_block;
296     if (m_opaque_ap->IsValid())
297         sb_block.SetPtr(m_opaque_ap->CalculateSymbolContextBlock());
298     return sb_block;
299 }
300 
301 SBSymbol
302 SBAddress::GetSymbol ()
303 {
304     SBSymbol sb_symbol;
305     if (m_opaque_ap->IsValid())
306         sb_symbol.reset(m_opaque_ap->CalculateSymbolContextSymbol());
307     return sb_symbol;
308 }
309 
310 SBLineEntry
311 SBAddress::GetLineEntry ()
312 {
313     SBLineEntry sb_line_entry;
314     if (m_opaque_ap->IsValid())
315     {
316         LineEntry line_entry;
317         if (m_opaque_ap->CalculateSymbolContextLineEntry (line_entry))
318             sb_line_entry.SetLineEntry (line_entry);
319     }
320     return sb_line_entry;
321 }
322 
323 AddressClass
324 SBAddress::GetAddressClass ()
325 {
326     if (m_opaque_ap->IsValid())
327         return m_opaque_ap->GetAddressClass();
328     return eAddressClassInvalid;
329 }
330 
331