1 //===-- SBFunction.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/SBFunction.h"
11 #include "lldb/API/SBProcess.h"
12 #include "lldb/API/SBStream.h"
13 #include "lldb/Core/Disassembler.h"
14 #include "lldb/Core/Module.h"
15 #include "lldb/Symbol/CompileUnit.h"
16 #include "lldb/Symbol/Function.h"
17 #include "lldb/Symbol/Type.h"
18 #include "lldb/Symbol/VariableList.h"
19 #include "lldb/Target/ExecutionContext.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Utility/Log.h"
22
23 using namespace lldb;
24 using namespace lldb_private;
25
SBFunction()26 SBFunction::SBFunction() : m_opaque_ptr(NULL) {}
27
SBFunction(lldb_private::Function * lldb_object_ptr)28 SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr)
29 : m_opaque_ptr(lldb_object_ptr) {}
30
SBFunction(const lldb::SBFunction & rhs)31 SBFunction::SBFunction(const lldb::SBFunction &rhs)
32 : m_opaque_ptr(rhs.m_opaque_ptr) {}
33
operator =(const SBFunction & rhs)34 const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
35 m_opaque_ptr = rhs.m_opaque_ptr;
36 return *this;
37 }
38
~SBFunction()39 SBFunction::~SBFunction() { m_opaque_ptr = NULL; }
40
IsValid() const41 bool SBFunction::IsValid() const { return m_opaque_ptr != NULL; }
42
GetName() const43 const char *SBFunction::GetName() const {
44 const char *cstr = NULL;
45 if (m_opaque_ptr)
46 cstr = m_opaque_ptr->GetName().AsCString();
47
48 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
49 if (log) {
50 if (cstr)
51 log->Printf("SBFunction(%p)::GetName () => \"%s\"",
52 static_cast<void *>(m_opaque_ptr), cstr);
53 else
54 log->Printf("SBFunction(%p)::GetName () => NULL",
55 static_cast<void *>(m_opaque_ptr));
56 }
57 return cstr;
58 }
59
GetDisplayName() const60 const char *SBFunction::GetDisplayName() const {
61 const char *cstr = NULL;
62 if (m_opaque_ptr)
63 cstr = m_opaque_ptr->GetMangled()
64 .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
65 .AsCString();
66
67 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
68 if (log) {
69 if (cstr)
70 log->Printf("SBFunction(%p)::GetDisplayName () => \"%s\"",
71 static_cast<void *>(m_opaque_ptr), cstr);
72 else
73 log->Printf("SBFunction(%p)::GetDisplayName () => NULL",
74 static_cast<void *>(m_opaque_ptr));
75 }
76 return cstr;
77 }
78
GetMangledName() const79 const char *SBFunction::GetMangledName() const {
80 const char *cstr = NULL;
81 if (m_opaque_ptr)
82 cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
83 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
84 if (log) {
85 if (cstr)
86 log->Printf("SBFunction(%p)::GetMangledName () => \"%s\"",
87 static_cast<void *>(m_opaque_ptr), cstr);
88 else
89 log->Printf("SBFunction(%p)::GetMangledName () => NULL",
90 static_cast<void *>(m_opaque_ptr));
91 }
92 return cstr;
93 }
94
operator ==(const SBFunction & rhs) const95 bool SBFunction::operator==(const SBFunction &rhs) const {
96 return m_opaque_ptr == rhs.m_opaque_ptr;
97 }
98
operator !=(const SBFunction & rhs) const99 bool SBFunction::operator!=(const SBFunction &rhs) const {
100 return m_opaque_ptr != rhs.m_opaque_ptr;
101 }
102
GetDescription(SBStream & s)103 bool SBFunction::GetDescription(SBStream &s) {
104 if (m_opaque_ptr) {
105 s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s",
106 m_opaque_ptr->GetID(), m_opaque_ptr->GetName().AsCString());
107 Type *func_type = m_opaque_ptr->GetType();
108 if (func_type)
109 s.Printf(", type = %s", func_type->GetName().AsCString());
110 return true;
111 }
112 s.Printf("No value");
113 return false;
114 }
115
GetInstructions(SBTarget target)116 SBInstructionList SBFunction::GetInstructions(SBTarget target) {
117 return GetInstructions(target, NULL);
118 }
119
GetInstructions(SBTarget target,const char * flavor)120 SBInstructionList SBFunction::GetInstructions(SBTarget target,
121 const char *flavor) {
122 SBInstructionList sb_instructions;
123 if (m_opaque_ptr) {
124 ExecutionContext exe_ctx;
125 TargetSP target_sp(target.GetSP());
126 std::unique_lock<std::recursive_mutex> lock;
127 if (target_sp) {
128 lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
129 target_sp->CalculateExecutionContext(exe_ctx);
130 exe_ctx.SetProcessSP(target_sp->GetProcessSP());
131 }
132 ModuleSP module_sp(
133 m_opaque_ptr->GetAddressRange().GetBaseAddress().GetModule());
134 if (module_sp) {
135 const bool prefer_file_cache = false;
136 sb_instructions.SetDisassembler(Disassembler::DisassembleRange(
137 module_sp->GetArchitecture(), NULL, flavor, exe_ctx,
138 m_opaque_ptr->GetAddressRange(), prefer_file_cache));
139 }
140 }
141 return sb_instructions;
142 }
143
get()144 lldb_private::Function *SBFunction::get() { return m_opaque_ptr; }
145
reset(lldb_private::Function * lldb_object_ptr)146 void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {
147 m_opaque_ptr = lldb_object_ptr;
148 }
149
GetStartAddress()150 SBAddress SBFunction::GetStartAddress() {
151 SBAddress addr;
152 if (m_opaque_ptr)
153 addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress());
154 return addr;
155 }
156
GetEndAddress()157 SBAddress SBFunction::GetEndAddress() {
158 SBAddress addr;
159 if (m_opaque_ptr) {
160 addr_t byte_size = m_opaque_ptr->GetAddressRange().GetByteSize();
161 if (byte_size > 0) {
162 addr.SetAddress(&m_opaque_ptr->GetAddressRange().GetBaseAddress());
163 addr->Slide(byte_size);
164 }
165 }
166 return addr;
167 }
168
GetArgumentName(uint32_t arg_idx)169 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
170 if (m_opaque_ptr) {
171 Block &block = m_opaque_ptr->GetBlock(true);
172 VariableListSP variable_list_sp = block.GetBlockVariableList(true);
173 if (variable_list_sp) {
174 VariableList arguments;
175 variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
176 arguments, true);
177 lldb::VariableSP variable_sp = arguments.GetVariableAtIndex(arg_idx);
178 if (variable_sp)
179 return variable_sp->GetName().GetCString();
180 }
181 }
182 return nullptr;
183 }
184
GetPrologueByteSize()185 uint32_t SBFunction::GetPrologueByteSize() {
186 if (m_opaque_ptr)
187 return m_opaque_ptr->GetPrologueByteSize();
188 return 0;
189 }
190
GetType()191 SBType SBFunction::GetType() {
192 SBType sb_type;
193 if (m_opaque_ptr) {
194 Type *function_type = m_opaque_ptr->GetType();
195 if (function_type)
196 sb_type.ref().SetType(function_type->shared_from_this());
197 }
198 return sb_type;
199 }
200
GetBlock()201 SBBlock SBFunction::GetBlock() {
202 SBBlock sb_block;
203 if (m_opaque_ptr)
204 sb_block.SetPtr(&m_opaque_ptr->GetBlock(true));
205 return sb_block;
206 }
207
GetLanguage()208 lldb::LanguageType SBFunction::GetLanguage() {
209 if (m_opaque_ptr) {
210 if (m_opaque_ptr->GetCompileUnit())
211 return m_opaque_ptr->GetCompileUnit()->GetLanguage();
212 }
213 return lldb::eLanguageTypeUnknown;
214 }
215
GetIsOptimized()216 bool SBFunction::GetIsOptimized() {
217 if (m_opaque_ptr) {
218 if (m_opaque_ptr->GetCompileUnit())
219 return m_opaque_ptr->GetCompileUnit()->GetIsOptimized();
220 }
221 return false;
222 }
223