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. If we
124   // weren't it is ok, the load address might be a location on the stack or
125   // heap, so we should just have an address with no section and a valid offset
126   if (!m_opaque_ap->IsValid())
127     m_opaque_ap->SetOffset(load_addr);
128 }
129 
130 bool SBAddress::OffsetAddress(addr_t offset) {
131   if (m_opaque_ap->IsValid()) {
132     addr_t addr_offset = m_opaque_ap->GetOffset();
133     if (addr_offset != LLDB_INVALID_ADDRESS) {
134       m_opaque_ap->SetOffset(addr_offset + offset);
135       return true;
136     }
137   }
138   return false;
139 }
140 
141 lldb::SBSection SBAddress::GetSection() {
142   lldb::SBSection sb_section;
143   if (m_opaque_ap->IsValid())
144     sb_section.SetSP(m_opaque_ap->GetSection());
145   return sb_section;
146 }
147 
148 lldb::addr_t SBAddress::GetOffset() {
149   if (m_opaque_ap->IsValid())
150     return m_opaque_ap->GetOffset();
151   return 0;
152 }
153 
154 Address *SBAddress::operator->() { return m_opaque_ap.get(); }
155 
156 const Address *SBAddress::operator->() const { return m_opaque_ap.get(); }
157 
158 Address &SBAddress::ref() {
159   if (m_opaque_ap.get() == NULL)
160     m_opaque_ap.reset(new Address());
161   return *m_opaque_ap;
162 }
163 
164 const Address &SBAddress::ref() const {
165   // This object should already have checked with "IsValid()" prior to calling
166   // this function. In case you didn't we will assert and die to let you know.
167   assert(m_opaque_ap.get());
168   return *m_opaque_ap;
169 }
170 
171 Address *SBAddress::get() { return m_opaque_ap.get(); }
172 
173 bool SBAddress::GetDescription(SBStream &description) {
174   // Call "ref()" on the stream to make sure it creates a backing stream in
175   // case there isn't one already...
176   Stream &strm = description.ref();
177   if (m_opaque_ap->IsValid()) {
178     m_opaque_ap->Dump(&strm, NULL, Address::DumpStyleResolvedDescription,
179                       Address::DumpStyleModuleWithFileAddress, 4);
180     StreamString sstrm;
181     //        m_opaque_ap->Dump (&sstrm, NULL,
182     //        Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid,
183     //        4);
184     //        if (sstrm.GetData())
185     //            strm.Printf (" (%s)", sstrm.GetData());
186   } else
187     strm.PutCString("No value");
188 
189   return true;
190 }
191 
192 SBModule SBAddress::GetModule() {
193   SBModule sb_module;
194   if (m_opaque_ap->IsValid())
195     sb_module.SetSP(m_opaque_ap->GetModule());
196   return sb_module;
197 }
198 
199 SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
200   SBSymbolContext sb_sc;
201   if (m_opaque_ap->IsValid())
202     m_opaque_ap->CalculateSymbolContext(&sb_sc.ref(), resolve_scope);
203   return sb_sc;
204 }
205 
206 SBCompileUnit SBAddress::GetCompileUnit() {
207   SBCompileUnit sb_comp_unit;
208   if (m_opaque_ap->IsValid())
209     sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit());
210   return sb_comp_unit;
211 }
212 
213 SBFunction SBAddress::GetFunction() {
214   SBFunction sb_function;
215   if (m_opaque_ap->IsValid())
216     sb_function.reset(m_opaque_ap->CalculateSymbolContextFunction());
217   return sb_function;
218 }
219 
220 SBBlock SBAddress::GetBlock() {
221   SBBlock sb_block;
222   if (m_opaque_ap->IsValid())
223     sb_block.SetPtr(m_opaque_ap->CalculateSymbolContextBlock());
224   return sb_block;
225 }
226 
227 SBSymbol SBAddress::GetSymbol() {
228   SBSymbol sb_symbol;
229   if (m_opaque_ap->IsValid())
230     sb_symbol.reset(m_opaque_ap->CalculateSymbolContextSymbol());
231   return sb_symbol;
232 }
233 
234 SBLineEntry SBAddress::GetLineEntry() {
235   SBLineEntry sb_line_entry;
236   if (m_opaque_ap->IsValid()) {
237     LineEntry line_entry;
238     if (m_opaque_ap->CalculateSymbolContextLineEntry(line_entry))
239       sb_line_entry.SetLineEntry(line_entry);
240   }
241   return sb_line_entry;
242 }
243