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 
22 SBSymbol::SBSymbol() : m_opaque_ptr(NULL) {}
23 
24 SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr)
25     : m_opaque_ptr(lldb_object_ptr) {}
26 
27 SBSymbol::SBSymbol(const lldb::SBSymbol &rhs)
28     : m_opaque_ptr(rhs.m_opaque_ptr) {}
29 
30 const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
31   m_opaque_ptr = rhs.m_opaque_ptr;
32   return *this;
33 }
34 
35 SBSymbol::~SBSymbol() { m_opaque_ptr = NULL; }
36 
37 void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
38   m_opaque_ptr = lldb_object_ptr;
39 }
40 
41 bool SBSymbol::IsValid() const { return m_opaque_ptr != NULL; }
42 
43 const char *SBSymbol::GetName() const {
44   const char *name = NULL;
45   if (m_opaque_ptr)
46     name = m_opaque_ptr->GetName().AsCString();
47 
48   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
49   if (log)
50     log->Printf("SBSymbol(%p)::GetName () => \"%s\"",
51                 static_cast<void *>(m_opaque_ptr), name ? name : "");
52   return name;
53 }
54 
55 const char *SBSymbol::GetDisplayName() const {
56   const char *name = NULL;
57   if (m_opaque_ptr)
58     name = m_opaque_ptr->GetMangled()
59                .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
60                .AsCString();
61 
62   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
63   if (log)
64     log->Printf("SBSymbol(%p)::GetDisplayName () => \"%s\"",
65                 static_cast<void *>(m_opaque_ptr), name ? name : "");
66   return name;
67 }
68 
69 const char *SBSymbol::GetMangledName() const {
70   const char *name = NULL;
71   if (m_opaque_ptr)
72     name = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
73   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
74   if (log)
75     log->Printf("SBSymbol(%p)::GetMangledName () => \"%s\"",
76                 static_cast<void *>(m_opaque_ptr), name ? name : "");
77 
78   return name;
79 }
80 
81 bool SBSymbol::operator==(const SBSymbol &rhs) const {
82   return m_opaque_ptr == rhs.m_opaque_ptr;
83 }
84 
85 bool SBSymbol::operator!=(const SBSymbol &rhs) const {
86   return m_opaque_ptr != rhs.m_opaque_ptr;
87 }
88 
89 bool SBSymbol::GetDescription(SBStream &description) {
90   Stream &strm = description.ref();
91 
92   if (m_opaque_ptr) {
93     m_opaque_ptr->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL);
94   } else
95     strm.PutCString("No value");
96 
97   return true;
98 }
99 
100 SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
101   return GetInstructions(target, NULL);
102 }
103 
104 SBInstructionList SBSymbol::GetInstructions(SBTarget target,
105                                             const char *flavor_string) {
106   SBInstructionList sb_instructions;
107   if (m_opaque_ptr) {
108     ExecutionContext exe_ctx;
109     TargetSP target_sp(target.GetSP());
110     std::unique_lock<std::recursive_mutex> lock;
111     if (target_sp) {
112       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
113 
114       target_sp->CalculateExecutionContext(exe_ctx);
115     }
116     if (m_opaque_ptr->ValueIsAddress()) {
117       const Address &symbol_addr = m_opaque_ptr->GetAddressRef();
118       ModuleSP module_sp = symbol_addr.GetModule();
119       if (module_sp) {
120         AddressRange symbol_range(symbol_addr, m_opaque_ptr->GetByteSize());
121         const bool prefer_file_cache = false;
122         sb_instructions.SetDisassembler(Disassembler::DisassembleRange(
123             module_sp->GetArchitecture(), NULL, flavor_string, exe_ctx,
124             symbol_range, prefer_file_cache));
125       }
126     }
127   }
128   return sb_instructions;
129 }
130 
131 lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
132 
133 void SBSymbol::reset(lldb_private::Symbol *symbol) { m_opaque_ptr = symbol; }
134 
135 SBAddress SBSymbol::GetStartAddress() {
136   SBAddress addr;
137   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
138     addr.SetAddress(&m_opaque_ptr->GetAddressRef());
139   }
140   return addr;
141 }
142 
143 SBAddress SBSymbol::GetEndAddress() {
144   SBAddress addr;
145   if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress()) {
146     lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
147     if (range_size > 0) {
148       addr.SetAddress(&m_opaque_ptr->GetAddressRef());
149       addr->Slide(m_opaque_ptr->GetByteSize());
150     }
151   }
152   return addr;
153 }
154 
155 uint32_t SBSymbol::GetPrologueByteSize() {
156   if (m_opaque_ptr)
157     return m_opaque_ptr->GetPrologueByteSize();
158   return 0;
159 }
160 
161 SymbolType SBSymbol::GetType() {
162   if (m_opaque_ptr)
163     return m_opaque_ptr->GetType();
164   return eSymbolTypeInvalid;
165 }
166 
167 bool SBSymbol::IsExternal() {
168   if (m_opaque_ptr)
169     return m_opaque_ptr->IsExternal();
170   return false;
171 }
172 
173 bool SBSymbol::IsSynthetic() {
174   if (m_opaque_ptr)
175     return m_opaque_ptr->IsSynthetic();
176   return false;
177 }
178