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