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