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