1//===-- SBFrame.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/SBFrame.h"
11
12#include <string>
13#include <algorithm>
14
15#include "lldb/lldb-types.h"
16
17#include "lldb/Core/Address.h"
18#include "lldb/Core/ConstString.h"
19#include "lldb/Core/Log.h"
20#include "lldb/Core/Stream.h"
21#include "lldb/Core/StreamFile.h"
22#include "lldb/Core/ValueObjectRegister.h"
23#include "lldb/Core/ValueObjectVariable.h"
24#include "lldb/Expression/ClangUserExpression.h"
25#include "lldb/Host/Host.h"
26#include "lldb/Symbol/Block.h"
27#include "lldb/Symbol/Function.h"
28#include "lldb/Symbol/Symbol.h"
29#include "lldb/Symbol/SymbolContext.h"
30#include "lldb/Symbol/VariableList.h"
31#include "lldb/Symbol/Variable.h"
32#include "lldb/Target/ExecutionContext.h"
33#include "lldb/Target/Target.h"
34#include "lldb/Target/Process.h"
35#include "lldb/Target/RegisterContext.h"
36#include "lldb/Target/StackFrame.h"
37#include "lldb/Target/StackID.h"
38#include "lldb/Target/Thread.h"
39
40#include "lldb/API/SBDebugger.h"
41#include "lldb/API/SBValue.h"
42#include "lldb/API/SBAddress.h"
43#include "lldb/API/SBExpressionOptions.h"
44#include "lldb/API/SBStream.h"
45#include "lldb/API/SBSymbolContext.h"
46#include "lldb/API/SBThread.h"
47
48using namespace lldb;
49using namespace lldb_private;
50
51
52SBFrame::SBFrame () :
53    m_opaque_sp (new ExecutionContextRef())
54{
55}
56
57SBFrame::SBFrame (const StackFrameSP &lldb_object_sp) :
58    m_opaque_sp (new ExecutionContextRef (lldb_object_sp))
59{
60    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
61
62    if (log)
63    {
64        SBStream sstr;
65        GetDescription (sstr);
66        log->Printf ("SBFrame::SBFrame (sp=%p) => SBFrame(%p): %s",
67                     lldb_object_sp.get(), lldb_object_sp.get(), sstr.GetData());
68
69    }
70}
71
72SBFrame::SBFrame(const SBFrame &rhs) :
73    m_opaque_sp (new ExecutionContextRef (*rhs.m_opaque_sp))
74{
75}
76
77const SBFrame &
78SBFrame::operator = (const SBFrame &rhs)
79{
80    if (this != &rhs)
81        *m_opaque_sp = *rhs.m_opaque_sp;
82    return *this;
83}
84
85SBFrame::~SBFrame()
86{
87}
88
89StackFrameSP
90SBFrame::GetFrameSP() const
91{
92    if (m_opaque_sp)
93        return m_opaque_sp->GetFrameSP();
94    return StackFrameSP();
95}
96
97void
98SBFrame::SetFrameSP (const StackFrameSP &lldb_object_sp)
99{
100    return m_opaque_sp->SetFrameSP(lldb_object_sp);
101}
102
103bool
104SBFrame::IsValid() const
105{
106    return GetFrameSP().get() != NULL;
107}
108
109SBSymbolContext
110SBFrame::GetSymbolContext (uint32_t resolve_scope) const
111{
112    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
113    SBSymbolContext sb_sym_ctx;
114    Mutex::Locker api_locker;
115    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
116
117    StackFrame *frame = NULL;
118    Target *target = exe_ctx.GetTargetPtr();
119    Process *process = exe_ctx.GetProcessPtr();
120    if (target && process)
121    {
122        Process::StopLocker stop_locker;
123        if (stop_locker.TryLock(&process->GetRunLock()))
124        {
125            frame = exe_ctx.GetFramePtr();
126            if (frame)
127            {
128                sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext (resolve_scope));
129            }
130            else
131            {
132                if (log)
133                    log->Printf ("SBFrame::GetVariables () => error: could not reconstruct frame object for this SBFrame.");
134            }
135        }
136        else
137        {
138            if (log)
139                log->Printf ("SBFrame::GetSymbolContext () => error: process is running");
140        }
141    }
142
143    if (log)
144        log->Printf ("SBFrame(%p)::GetSymbolContext (resolve_scope=0x%8.8x) => SBSymbolContext(%p)",
145                     frame, resolve_scope, sb_sym_ctx.get());
146
147    return sb_sym_ctx;
148}
149
150SBModule
151SBFrame::GetModule () const
152{
153    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
154    SBModule sb_module;
155    ModuleSP module_sp;
156    Mutex::Locker api_locker;
157    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
158
159    StackFrame *frame = NULL;
160    Target *target = exe_ctx.GetTargetPtr();
161    Process *process = exe_ctx.GetProcessPtr();
162    if (target && process)
163    {
164        Process::StopLocker stop_locker;
165        if (stop_locker.TryLock(&process->GetRunLock()))
166        {
167            frame = exe_ctx.GetFramePtr();
168            if (frame)
169            {
170                module_sp = frame->GetSymbolContext (eSymbolContextModule).module_sp;
171                sb_module.SetSP (module_sp);
172            }
173            else
174            {
175                if (log)
176                    log->Printf ("SBFrame::GetModule () => error: could not reconstruct frame object for this SBFrame.");
177            }
178        }
179        else
180        {
181            if (log)
182                log->Printf ("SBFrame::GetModule () => error: process is running");
183        }
184    }
185
186    if (log)
187        log->Printf ("SBFrame(%p)::GetModule () => SBModule(%p)",
188                     frame, module_sp.get());
189
190    return sb_module;
191}
192
193SBCompileUnit
194SBFrame::GetCompileUnit () const
195{
196    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
197    SBCompileUnit sb_comp_unit;
198    Mutex::Locker api_locker;
199    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
200
201    StackFrame *frame = NULL;
202    Target *target = exe_ctx.GetTargetPtr();
203    Process *process = exe_ctx.GetProcessPtr();
204    if (target && process)
205    {
206        Process::StopLocker stop_locker;
207        if (stop_locker.TryLock(&process->GetRunLock()))
208        {
209            frame = exe_ctx.GetFramePtr();
210            if (frame)
211            {
212                sb_comp_unit.reset (frame->GetSymbolContext (eSymbolContextCompUnit).comp_unit);
213            }
214            else
215            {
216                if (log)
217                    log->Printf ("SBFrame::GetCompileUnit () => error: could not reconstruct frame object for this SBFrame.");
218            }
219        }
220        else
221        {
222            if (log)
223                log->Printf ("SBFrame::GetCompileUnit () => error: process is running");
224        }
225    }
226    if (log)
227        log->Printf ("SBFrame(%p)::GetCompileUnit () => SBCompileUnit(%p)",
228                     frame, sb_comp_unit.get());
229
230    return sb_comp_unit;
231}
232
233SBFunction
234SBFrame::GetFunction () const
235{
236    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
237    SBFunction sb_function;
238    Mutex::Locker api_locker;
239    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
240
241    StackFrame *frame = NULL;
242    Target *target = exe_ctx.GetTargetPtr();
243    Process *process = exe_ctx.GetProcessPtr();
244    if (target && process)
245    {
246        Process::StopLocker stop_locker;
247        if (stop_locker.TryLock(&process->GetRunLock()))
248        {
249            frame = exe_ctx.GetFramePtr();
250            if (frame)
251            {
252                sb_function.reset(frame->GetSymbolContext (eSymbolContextFunction).function);
253            }
254            else
255            {
256                if (log)
257                    log->Printf ("SBFrame::GetFunction () => error: could not reconstruct frame object for this SBFrame.");
258            }
259        }
260        else
261        {
262            if (log)
263                log->Printf ("SBFrame::GetFunction () => error: process is running");
264        }
265    }
266    if (log)
267        log->Printf ("SBFrame(%p)::GetFunction () => SBFunction(%p)",
268                     frame, sb_function.get());
269
270    return sb_function;
271}
272
273SBSymbol
274SBFrame::GetSymbol () const
275{
276    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
277    SBSymbol sb_symbol;
278    Mutex::Locker api_locker;
279    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
280
281    StackFrame *frame = NULL;
282    Target *target = exe_ctx.GetTargetPtr();
283    Process *process = exe_ctx.GetProcessPtr();
284    if (target && process)
285    {
286        Process::StopLocker stop_locker;
287        if (stop_locker.TryLock(&process->GetRunLock()))
288        {
289            frame = exe_ctx.GetFramePtr();
290            if (frame)
291            {
292                sb_symbol.reset(frame->GetSymbolContext (eSymbolContextSymbol).symbol);
293            }
294            else
295            {
296                if (log)
297                    log->Printf ("SBFrame::GetSymbol () => error: could not reconstruct frame object for this SBFrame.");
298            }
299        }
300        else
301        {
302            if (log)
303                log->Printf ("SBFrame::GetSymbol () => error: process is running");
304        }
305    }
306    if (log)
307        log->Printf ("SBFrame(%p)::GetSymbol () => SBSymbol(%p)",
308                     frame, sb_symbol.get());
309    return sb_symbol;
310}
311
312SBBlock
313SBFrame::GetBlock () const
314{
315    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
316    SBBlock sb_block;
317    Mutex::Locker api_locker;
318    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
319
320    StackFrame *frame = NULL;
321    Target *target = exe_ctx.GetTargetPtr();
322    Process *process = exe_ctx.GetProcessPtr();
323    if (target && process)
324    {
325        Process::StopLocker stop_locker;
326        if (stop_locker.TryLock(&process->GetRunLock()))
327        {
328            frame = exe_ctx.GetFramePtr();
329            if (frame)
330            {
331                sb_block.SetPtr (frame->GetSymbolContext (eSymbolContextBlock).block);
332            }
333            else
334            {
335                if (log)
336                    log->Printf ("SBFrame::GetBlock () => error: could not reconstruct frame object for this SBFrame.");
337            }
338        }
339        else
340        {
341            if (log)
342                log->Printf ("SBFrame(%p)::GetBlock () => error: process is running", frame);
343        }
344    }
345    if (log)
346        log->Printf ("SBFrame(%p)::GetBlock () => SBBlock(%p)",
347                     frame, sb_block.GetPtr());
348    return sb_block;
349}
350
351SBBlock
352SBFrame::GetFrameBlock () const
353{
354    SBBlock sb_block;
355    Mutex::Locker api_locker;
356    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
357
358    StackFrame *frame = NULL;
359    Target *target = exe_ctx.GetTargetPtr();
360    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
361    Process *process = exe_ctx.GetProcessPtr();
362    if (target && process)
363    {
364        Process::StopLocker stop_locker;
365        if (stop_locker.TryLock(&process->GetRunLock()))
366        {
367            frame = exe_ctx.GetFramePtr();
368            if (frame)
369            {
370                sb_block.SetPtr(frame->GetFrameBlock ());
371            }
372            else
373            {
374                if (log)
375                    log->Printf ("SBFrame::GetFrameBlock () => error: could not reconstruct frame object for this SBFrame.");
376            }
377        }
378        else
379        {
380            if (log)
381                log->Printf ("SBFrame::GetFrameBlock () => error: process is running");
382        }
383    }
384    if (log)
385        log->Printf ("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)",
386                     frame, sb_block.GetPtr());
387    return sb_block;
388}
389
390SBLineEntry
391SBFrame::GetLineEntry () const
392{
393    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
394    SBLineEntry sb_line_entry;
395    Mutex::Locker api_locker;
396    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
397
398    StackFrame *frame = NULL;
399    Target *target = exe_ctx.GetTargetPtr();
400    Process *process = exe_ctx.GetProcessPtr();
401    if (target && process)
402    {
403        Process::StopLocker stop_locker;
404        if (stop_locker.TryLock(&process->GetRunLock()))
405        {
406            frame = exe_ctx.GetFramePtr();
407            if (frame)
408            {
409                sb_line_entry.SetLineEntry (frame->GetSymbolContext (eSymbolContextLineEntry).line_entry);
410            }
411            else
412            {
413                if (log)
414                    log->Printf ("SBFrame::GetLineEntry () => error: could not reconstruct frame object for this SBFrame.");
415            }
416        }
417        else
418        {
419            if (log)
420                log->Printf ("SBFrame::GetLineEntry () => error: process is running");
421        }
422    }
423    if (log)
424        log->Printf ("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)",
425                     frame, sb_line_entry.get());
426    return sb_line_entry;
427}
428
429uint32_t
430SBFrame::GetFrameID () const
431{
432    uint32_t frame_idx = UINT32_MAX;
433
434    ExecutionContext exe_ctx(m_opaque_sp.get());
435    StackFrame *frame = exe_ctx.GetFramePtr();
436    if (frame)
437        frame_idx = frame->GetFrameIndex ();
438
439    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
440    if (log)
441        log->Printf ("SBFrame(%p)::GetFrameID () => %u",
442                     frame, frame_idx);
443    return frame_idx;
444}
445
446addr_t
447SBFrame::GetPC () const
448{
449    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
450    addr_t addr = LLDB_INVALID_ADDRESS;
451    Mutex::Locker api_locker;
452    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
453
454    StackFrame *frame = NULL;
455    Target *target = exe_ctx.GetTargetPtr();
456    Process *process = exe_ctx.GetProcessPtr();
457    if (target && process)
458    {
459        Process::StopLocker stop_locker;
460        if (stop_locker.TryLock(&process->GetRunLock()))
461        {
462            frame = exe_ctx.GetFramePtr();
463            if (frame)
464            {
465                addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress (target);
466            }
467            else
468            {
469                if (log)
470                    log->Printf ("SBFrame::GetPC () => error: could not reconstruct frame object for this SBFrame.");
471            }
472        }
473        else
474        {
475            if (log)
476                log->Printf ("SBFrame::GetPC () => error: process is running");
477        }
478    }
479
480    if (log)
481        log->Printf ("SBFrame(%p)::GetPC () => 0x%" PRIx64, frame, addr);
482
483    return addr;
484}
485
486bool
487SBFrame::SetPC (addr_t new_pc)
488{
489    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
490    bool ret_val = false;
491    Mutex::Locker api_locker;
492    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
493
494    StackFrame *frame = NULL;
495    Target *target = exe_ctx.GetTargetPtr();
496    Process *process = exe_ctx.GetProcessPtr();
497    if (target && process)
498    {
499        Process::StopLocker stop_locker;
500        if (stop_locker.TryLock(&process->GetRunLock()))
501        {
502            frame = exe_ctx.GetFramePtr();
503            if (frame)
504            {
505                ret_val = frame->GetRegisterContext()->SetPC (new_pc);
506            }
507            else
508            {
509                if (log)
510                    log->Printf ("SBFrame::SetPC () => error: could not reconstruct frame object for this SBFrame.");
511            }
512        }
513        else
514        {
515            if (log)
516                log->Printf ("SBFrame::SetPC () => error: process is running");
517        }
518    }
519
520    if (log)
521        log->Printf ("SBFrame(%p)::SetPC (new_pc=0x%" PRIx64 ") => %i",
522                     frame, new_pc, ret_val);
523
524    return ret_val;
525}
526
527addr_t
528SBFrame::GetSP () const
529{
530    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
531    addr_t addr = LLDB_INVALID_ADDRESS;
532    Mutex::Locker api_locker;
533    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
534
535    StackFrame *frame = NULL;
536    Target *target = exe_ctx.GetTargetPtr();
537    Process *process = exe_ctx.GetProcessPtr();
538    if (target && process)
539    {
540        Process::StopLocker stop_locker;
541        if (stop_locker.TryLock(&process->GetRunLock()))
542        {
543            frame = exe_ctx.GetFramePtr();
544            if (frame)
545            {
546                addr = frame->GetRegisterContext()->GetSP();
547            }
548            else
549            {
550                if (log)
551                    log->Printf ("SBFrame::GetSP () => error: could not reconstruct frame object for this SBFrame.");
552            }
553        }
554        else
555        {
556            if (log)
557                log->Printf ("SBFrame::GetSP () => error: process is running");
558        }
559    }
560    if (log)
561        log->Printf ("SBFrame(%p)::GetSP () => 0x%" PRIx64, frame, addr);
562
563    return addr;
564}
565
566
567addr_t
568SBFrame::GetFP () const
569{
570    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
571    addr_t addr = LLDB_INVALID_ADDRESS;
572    Mutex::Locker api_locker;
573    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
574
575    StackFrame *frame = NULL;
576    Target *target = exe_ctx.GetTargetPtr();
577    Process *process = exe_ctx.GetProcessPtr();
578    if (target && process)
579    {
580        Process::StopLocker stop_locker;
581        if (stop_locker.TryLock(&process->GetRunLock()))
582        {
583            frame = exe_ctx.GetFramePtr();
584            if (frame)
585            {
586                addr = frame->GetRegisterContext()->GetFP();
587            }
588            else
589            {
590                if (log)
591                    log->Printf ("SBFrame::GetFP () => error: could not reconstruct frame object for this SBFrame.");
592            }
593        }
594        else
595        {
596            if (log)
597                log->Printf ("SBFrame::GetFP () => error: process is running");
598        }
599    }
600
601    if (log)
602        log->Printf ("SBFrame(%p)::GetFP () => 0x%" PRIx64, frame, addr);
603    return addr;
604}
605
606
607SBAddress
608SBFrame::GetPCAddress () const
609{
610    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
611    SBAddress sb_addr;
612    Mutex::Locker api_locker;
613    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
614
615    StackFrame *frame = exe_ctx.GetFramePtr();
616    Target *target = exe_ctx.GetTargetPtr();
617    Process *process = exe_ctx.GetProcessPtr();
618    if (target && process)
619    {
620        Process::StopLocker stop_locker;
621        if (stop_locker.TryLock(&process->GetRunLock()))
622        {
623            frame = exe_ctx.GetFramePtr();
624            if (frame)
625            {
626                sb_addr.SetAddress (&frame->GetFrameCodeAddress());
627            }
628            else
629            {
630                if (log)
631                    log->Printf ("SBFrame::GetPCAddress () => error: could not reconstruct frame object for this SBFrame.");
632            }
633        }
634        else
635        {
636            if (log)
637                log->Printf ("SBFrame::GetPCAddress () => error: process is running");
638        }
639    }
640    if (log)
641        log->Printf ("SBFrame(%p)::GetPCAddress () => SBAddress(%p)", frame, sb_addr.get());
642    return sb_addr;
643}
644
645void
646SBFrame::Clear()
647{
648    m_opaque_sp->Clear();
649}
650
651lldb::SBValue
652SBFrame::GetValueForVariablePath (const char *var_path)
653{
654    SBValue sb_value;
655    ExecutionContext exe_ctx(m_opaque_sp.get());
656    StackFrame *frame = exe_ctx.GetFramePtr();
657    Target *target = exe_ctx.GetTargetPtr();
658    if (frame && target)
659    {
660        lldb::DynamicValueType  use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
661        sb_value = GetValueForVariablePath (var_path, use_dynamic);
662    }
663    return sb_value;
664}
665
666lldb::SBValue
667SBFrame::GetValueForVariablePath (const char *var_path, DynamicValueType use_dynamic)
668{
669    SBValue sb_value;
670    Mutex::Locker api_locker;
671    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
672    if (var_path == NULL || var_path[0] == '\0')
673    {
674        if (log)
675            log->Printf ("SBFrame::GetValueForVariablePath called with empty variable path.");
676        return sb_value;
677    }
678
679    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
680
681    StackFrame *frame = NULL;
682    Target *target = exe_ctx.GetTargetPtr();
683    Process *process = exe_ctx.GetProcessPtr();
684    if (target && process)
685    {
686        Process::StopLocker stop_locker;
687        if (stop_locker.TryLock(&process->GetRunLock()))
688        {
689            frame = exe_ctx.GetFramePtr();
690            if (frame)
691            {
692                VariableSP var_sp;
693                Error error;
694                ValueObjectSP value_sp (frame->GetValueForVariableExpressionPath (var_path,
695                                                                                  eNoDynamicValues,
696                                                                                  StackFrame::eExpressionPathOptionCheckPtrVsMember | StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
697                                                                                  var_sp,
698                                                                                  error));
699                sb_value.SetSP(value_sp, use_dynamic);
700            }
701            else
702            {
703                if (log)
704                    log->Printf ("SBFrame::GetValueForVariablePath () => error: could not reconstruct frame object for this SBFrame.");
705            }
706        }
707        else
708        {
709            if (log)
710                log->Printf ("SBFrame::GetValueForVariablePath () => error: process is running");
711        }
712    }
713    return sb_value;
714}
715
716SBValue
717SBFrame::FindVariable (const char *name)
718{
719    SBValue value;
720    ExecutionContext exe_ctx(m_opaque_sp.get());
721    StackFrame *frame = exe_ctx.GetFramePtr();
722    Target *target = exe_ctx.GetTargetPtr();
723    if (frame && target)
724    {
725        lldb::DynamicValueType  use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
726        value = FindVariable (name, use_dynamic);
727    }
728    return value;
729}
730
731
732SBValue
733SBFrame::FindVariable (const char *name, lldb::DynamicValueType use_dynamic)
734{
735    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
736    VariableSP var_sp;
737    SBValue sb_value;
738
739    if (name == NULL || name[0] == '\0')
740    {
741        if (log)
742            log->Printf ("SBFrame::FindVariable called with empty name");
743        return sb_value;
744    }
745
746    ValueObjectSP value_sp;
747    Mutex::Locker api_locker;
748    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
749
750    StackFrame *frame = NULL;
751    Target *target = exe_ctx.GetTargetPtr();
752    Process *process = exe_ctx.GetProcessPtr();
753    if (target && process)
754    {
755        Process::StopLocker stop_locker;
756        if (stop_locker.TryLock(&process->GetRunLock()))
757        {
758            frame = exe_ctx.GetFramePtr();
759            if (frame)
760            {
761                VariableList variable_list;
762                SymbolContext sc (frame->GetSymbolContext (eSymbolContextBlock));
763
764                if (sc.block)
765                {
766                    const bool can_create = true;
767                    const bool get_parent_variables = true;
768                    const bool stop_if_block_is_inlined_function = true;
769
770                    if (sc.block->AppendVariables (can_create,
771                                                   get_parent_variables,
772                                                   stop_if_block_is_inlined_function,
773                                                   &variable_list))
774                    {
775                        var_sp = variable_list.FindVariable (ConstString(name));
776                    }
777                }
778
779                if (var_sp)
780                {
781                    value_sp = frame->GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
782                    sb_value.SetSP(value_sp, use_dynamic);
783                }
784            }
785            else
786            {
787                if (log)
788                    log->Printf ("SBFrame::FindVariable () => error: could not reconstruct frame object for this SBFrame.");
789            }
790        }
791        else
792        {
793            if (log)
794                log->Printf ("SBFrame::FindVariable () => error: process is running");
795        }
796    }
797
798    if (log)
799        log->Printf ("SBFrame(%p)::FindVariable (name=\"%s\") => SBValue(%p)",
800                     frame, name, value_sp.get());
801
802    return sb_value;
803}
804
805SBValue
806SBFrame::FindValue (const char *name, ValueType value_type)
807{
808    SBValue value;
809    ExecutionContext exe_ctx(m_opaque_sp.get());
810    StackFrame *frame = exe_ctx.GetFramePtr();
811    Target *target = exe_ctx.GetTargetPtr();
812    if (frame && target)
813    {
814        lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
815        value = FindValue (name, value_type, use_dynamic);
816    }
817    return value;
818}
819
820SBValue
821SBFrame::FindValue (const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic)
822{
823    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
824    SBValue sb_value;
825
826    if (name == NULL || name[0] == '\0')
827    {
828        if (log)
829            log->Printf ("SBFrame::FindValue called with empty name.");
830        return sb_value;
831    }
832
833    ValueObjectSP value_sp;
834    Mutex::Locker api_locker;
835    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
836
837    StackFrame *frame = NULL;
838    Target *target = exe_ctx.GetTargetPtr();
839    Process *process = exe_ctx.GetProcessPtr();
840    if (target && process)
841    {
842        Process::StopLocker stop_locker;
843        if (stop_locker.TryLock(&process->GetRunLock()))
844        {
845            frame = exe_ctx.GetFramePtr();
846            if (frame)
847            {
848                switch (value_type)
849                {
850                case eValueTypeVariableGlobal:      // global variable
851                case eValueTypeVariableStatic:      // static variable
852                case eValueTypeVariableArgument:    // function argument variables
853                case eValueTypeVariableLocal:       // function local variables
854                    {
855                        VariableList *variable_list = frame->GetVariableList(true);
856
857                        SymbolContext sc (frame->GetSymbolContext (eSymbolContextBlock));
858
859                        const bool can_create = true;
860                        const bool get_parent_variables = true;
861                        const bool stop_if_block_is_inlined_function = true;
862
863                        if (sc.block && sc.block->AppendVariables (can_create,
864                                                                   get_parent_variables,
865                                                                   stop_if_block_is_inlined_function,
866                                                                   variable_list))
867                        {
868                            ConstString const_name(name);
869                            const uint32_t num_variables = variable_list->GetSize();
870                            for (uint32_t i = 0; i < num_variables; ++i)
871                            {
872                                VariableSP variable_sp (variable_list->GetVariableAtIndex(i));
873                                if (variable_sp &&
874                                    variable_sp->GetScope() == value_type &&
875                                    variable_sp->GetName() == const_name)
876                                {
877                                    value_sp = frame->GetValueObjectForFrameVariable (variable_sp, eNoDynamicValues);
878                                    sb_value.SetSP (value_sp, use_dynamic);
879                                    break;
880                                }
881                            }
882                        }
883                    }
884                    break;
885
886                case eValueTypeRegister:            // stack frame register value
887                    {
888                        RegisterContextSP reg_ctx (frame->GetRegisterContext());
889                        if (reg_ctx)
890                        {
891                            const uint32_t num_regs = reg_ctx->GetRegisterCount();
892                            for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
893                            {
894                                const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx);
895                                if (reg_info &&
896                                    ((reg_info->name && strcasecmp (reg_info->name, name) == 0) ||
897                                     (reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0)))
898                                {
899                                    value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx);
900                                    sb_value.SetSP (value_sp);
901                                    break;
902                                }
903                            }
904                        }
905                    }
906                    break;
907
908                case eValueTypeRegisterSet:         // A collection of stack frame register values
909                    {
910                        RegisterContextSP reg_ctx (frame->GetRegisterContext());
911                        if (reg_ctx)
912                        {
913                            const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
914                            for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
915                            {
916                                const RegisterSet *reg_set = reg_ctx->GetRegisterSet (set_idx);
917                                if (reg_set &&
918                                    ((reg_set->name && strcasecmp (reg_set->name, name) == 0) ||
919                                     (reg_set->short_name && strcasecmp (reg_set->short_name, name) == 0)))
920                                {
921                                    value_sp = ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx);
922                                    sb_value.SetSP (value_sp);
923                                    break;
924                                }
925                            }
926                        }
927                    }
928                    break;
929
930                case eValueTypeConstResult:         // constant result variables
931                    {
932                        ConstString const_name(name);
933                        ClangExpressionVariableSP expr_var_sp (target->GetPersistentVariables().GetVariable (const_name));
934                        if (expr_var_sp)
935                        {
936                            value_sp = expr_var_sp->GetValueObject();
937                            sb_value.SetSP (value_sp, use_dynamic);
938                        }
939                    }
940                    break;
941
942                default:
943                    break;
944                }
945            }
946            else
947            {
948                if (log)
949                    log->Printf ("SBFrame::FindValue () => error: could not reconstruct frame object for this SBFrame.");
950            }
951        }
952        else
953        {
954            if (log)
955                log->Printf ("SBFrame::FindValue () => error: process is running");
956        }
957    }
958
959    if (log)
960        log->Printf ("SBFrame(%p)::FindVariableInScope (name=\"%s\", value_type=%i) => SBValue(%p)",
961                     frame, name, value_type, value_sp.get());
962
963
964    return sb_value;
965}
966
967bool
968SBFrame::IsEqual (const SBFrame &that) const
969{
970    lldb::StackFrameSP this_sp = GetFrameSP();
971    lldb::StackFrameSP that_sp = that.GetFrameSP();
972    return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
973}
974
975bool
976SBFrame::operator == (const SBFrame &rhs) const
977{
978    return IsEqual(rhs);
979}
980
981bool
982SBFrame::operator != (const SBFrame &rhs) const
983{
984    return !IsEqual(rhs);
985}
986
987SBThread
988SBFrame::GetThread () const
989{
990    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
991
992    ExecutionContext exe_ctx(m_opaque_sp.get());
993    ThreadSP thread_sp (exe_ctx.GetThreadSP());
994    SBThread sb_thread (thread_sp);
995
996    if (log)
997    {
998        SBStream sstr;
999        sb_thread.GetDescription (sstr);
1000        log->Printf ("SBFrame(%p)::GetThread () => SBThread(%p): %s",
1001                     exe_ctx.GetFramePtr(),
1002                     thread_sp.get(),
1003                     sstr.GetData());
1004    }
1005
1006    return sb_thread;
1007}
1008
1009const char *
1010SBFrame::Disassemble () const
1011{
1012    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1013    const char *disassembly = NULL;
1014    Mutex::Locker api_locker;
1015    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1016
1017    StackFrame *frame = NULL;
1018    Target *target = exe_ctx.GetTargetPtr();
1019    Process *process = exe_ctx.GetProcessPtr();
1020    if (target && process)
1021    {
1022        Process::StopLocker stop_locker;
1023        if (stop_locker.TryLock(&process->GetRunLock()))
1024        {
1025            frame = exe_ctx.GetFramePtr();
1026            if (frame)
1027            {
1028                disassembly = frame->Disassemble();
1029            }
1030            else
1031            {
1032                if (log)
1033                    log->Printf ("SBFrame::Disassemble () => error: could not reconstruct frame object for this SBFrame.");
1034            }
1035        }
1036        else
1037        {
1038            if (log)
1039                log->Printf ("SBFrame::Disassemble () => error: process is running");
1040        }
1041    }
1042
1043    if (log)
1044        log->Printf ("SBFrame(%p)::Disassemble () => %s", frame, disassembly);
1045
1046    return disassembly;
1047}
1048
1049
1050SBValueList
1051SBFrame::GetVariables (bool arguments,
1052                       bool locals,
1053                       bool statics,
1054                       bool in_scope_only)
1055{
1056    SBValueList value_list;
1057    ExecutionContext exe_ctx(m_opaque_sp.get());
1058    StackFrame *frame = exe_ctx.GetFramePtr();
1059    Target *target = exe_ctx.GetTargetPtr();
1060    if (frame && target)
1061    {
1062        lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
1063        value_list = GetVariables (arguments, locals, statics, in_scope_only, use_dynamic);
1064    }
1065    return value_list;
1066}
1067
1068SBValueList
1069SBFrame::GetVariables (bool arguments,
1070                       bool locals,
1071                       bool statics,
1072                       bool in_scope_only,
1073                       lldb::DynamicValueType  use_dynamic)
1074{
1075    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1076
1077    SBValueList value_list;
1078    Mutex::Locker api_locker;
1079    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1080
1081    StackFrame *frame = NULL;
1082    Target *target = exe_ctx.GetTargetPtr();
1083
1084    if (log)
1085        log->Printf ("SBFrame::GetVariables (arguments=%i, locals=%i, statics=%i, in_scope_only=%i)",
1086                     arguments,
1087                     locals,
1088                     statics,
1089                     in_scope_only);
1090
1091    Process *process = exe_ctx.GetProcessPtr();
1092    if (target && process)
1093    {
1094        Process::StopLocker stop_locker;
1095        if (stop_locker.TryLock(&process->GetRunLock()))
1096        {
1097            frame = exe_ctx.GetFramePtr();
1098            if (frame)
1099            {
1100                size_t i;
1101                VariableList *variable_list = NULL;
1102                variable_list = frame->GetVariableList(true);
1103                if (variable_list)
1104                {
1105                    const size_t num_variables = variable_list->GetSize();
1106                    if (num_variables)
1107                    {
1108                        for (i = 0; i < num_variables; ++i)
1109                        {
1110                            VariableSP variable_sp (variable_list->GetVariableAtIndex(i));
1111                            if (variable_sp)
1112                            {
1113                                bool add_variable = false;
1114                                switch (variable_sp->GetScope())
1115                                {
1116                                case eValueTypeVariableGlobal:
1117                                case eValueTypeVariableStatic:
1118                                    add_variable = statics;
1119                                    break;
1120
1121                                case eValueTypeVariableArgument:
1122                                    add_variable = arguments;
1123                                    break;
1124
1125                                case eValueTypeVariableLocal:
1126                                    add_variable = locals;
1127                                    break;
1128
1129                                default:
1130                                    break;
1131                                }
1132                                if (add_variable)
1133                                {
1134                                    if (in_scope_only && !variable_sp->IsInScope(frame))
1135                                        continue;
1136
1137                                    ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable (variable_sp, eNoDynamicValues));
1138                                    SBValue value_sb;
1139                                    value_sb.SetSP(valobj_sp,use_dynamic);
1140                                    value_list.Append(value_sb);
1141                                }
1142                            }
1143                        }
1144                    }
1145                }
1146            }
1147            else
1148            {
1149                if (log)
1150                    log->Printf ("SBFrame::GetVariables () => error: could not reconstruct frame object for this SBFrame.");
1151            }
1152        }
1153        else
1154        {
1155            if (log)
1156                log->Printf ("SBFrame::GetVariables () => error: process is running");
1157        }
1158    }
1159
1160    if (log)
1161    {
1162        log->Printf ("SBFrame(%p)::GetVariables (...) => SBValueList(%p)", frame, value_list.opaque_ptr());
1163    }
1164
1165    return value_list;
1166}
1167
1168SBValueList
1169SBFrame::GetRegisters ()
1170{
1171    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1172
1173    SBValueList value_list;
1174    Mutex::Locker api_locker;
1175    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1176
1177    StackFrame *frame = NULL;
1178    Target *target = exe_ctx.GetTargetPtr();
1179    Process *process = exe_ctx.GetProcessPtr();
1180    if (target && process)
1181    {
1182        Process::StopLocker stop_locker;
1183        if (stop_locker.TryLock(&process->GetRunLock()))
1184        {
1185            frame = exe_ctx.GetFramePtr();
1186            if (frame)
1187            {
1188                RegisterContextSP reg_ctx (frame->GetRegisterContext());
1189                if (reg_ctx)
1190                {
1191                    const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
1192                    for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
1193                    {
1194                        value_list.Append(ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx));
1195                    }
1196                }
1197            }
1198            else
1199            {
1200                if (log)
1201                    log->Printf ("SBFrame::GetRegisters () => error: could not reconstruct frame object for this SBFrame.");
1202            }
1203        }
1204        else
1205        {
1206            if (log)
1207                log->Printf ("SBFrame::GetRegisters () => error: process is running");
1208        }
1209    }
1210
1211    if (log)
1212        log->Printf ("SBFrame(%p)::GetRegisters () => SBValueList(%p)", frame, value_list.opaque_ptr());
1213
1214    return value_list;
1215}
1216
1217SBValue
1218SBFrame::FindRegister (const char *name)
1219{
1220    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1221
1222    SBValue result;
1223    ValueObjectSP value_sp;
1224    Mutex::Locker api_locker;
1225    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1226
1227    StackFrame *frame = NULL;
1228    Target *target = exe_ctx.GetTargetPtr();
1229    Process *process = exe_ctx.GetProcessPtr();
1230    if (target && process)
1231    {
1232        Process::StopLocker stop_locker;
1233        if (stop_locker.TryLock(&process->GetRunLock()))
1234        {
1235            frame = exe_ctx.GetFramePtr();
1236            if (frame)
1237            {
1238                RegisterContextSP reg_ctx (frame->GetRegisterContext());
1239                if (reg_ctx)
1240                {
1241                    const uint32_t num_regs = reg_ctx->GetRegisterCount();
1242                    for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
1243                    {
1244                        const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx);
1245                        if (reg_info &&
1246                            ((reg_info->name && strcasecmp (reg_info->name, name) == 0) ||
1247                             (reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0)))
1248                        {
1249                            value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx);
1250                            result.SetSP (value_sp);
1251                            break;
1252                        }
1253                    }
1254                }
1255            }
1256            else
1257            {
1258                if (log)
1259                    log->Printf ("SBFrame::FindRegister () => error: could not reconstruct frame object for this SBFrame.");
1260            }
1261        }
1262        else
1263        {
1264            if (log)
1265                log->Printf ("SBFrame::FindRegister () => error: process is running");
1266        }
1267    }
1268
1269    if (log)
1270        log->Printf ("SBFrame(%p)::FindRegister () => SBValue(%p)", frame, value_sp.get());
1271
1272    return result;
1273}
1274
1275bool
1276SBFrame::GetDescription (SBStream &description)
1277{
1278    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1279    Stream &strm = description.ref();
1280
1281    Mutex::Locker api_locker;
1282    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1283
1284    StackFrame *frame;
1285    Target *target = exe_ctx.GetTargetPtr();
1286    Process *process = exe_ctx.GetProcessPtr();
1287    if (target && process)
1288    {
1289        Process::StopLocker stop_locker;
1290        if (stop_locker.TryLock(&process->GetRunLock()))
1291        {
1292            frame = exe_ctx.GetFramePtr();
1293            if (frame)
1294            {
1295                frame->DumpUsingSettingsFormat (&strm);
1296            }
1297            else
1298            {
1299                if (log)
1300                    log->Printf ("SBFrame::GetDescription () => error: could not reconstruct frame object for this SBFrame.");
1301            }
1302        }
1303        else
1304        {
1305            if (log)
1306                log->Printf ("SBFrame::GetDescription () => error: process is running");
1307        }
1308
1309    }
1310    else
1311        strm.PutCString ("No value");
1312
1313    return true;
1314}
1315
1316SBValue
1317SBFrame::EvaluateExpression (const char *expr)
1318{
1319    SBValue result;
1320    ExecutionContext exe_ctx(m_opaque_sp.get());
1321    StackFrame *frame = exe_ctx.GetFramePtr();
1322    Target *target = exe_ctx.GetTargetPtr();
1323    if (frame && target)
1324    {
1325        SBExpressionOptions options;
1326        lldb::DynamicValueType fetch_dynamic_value = frame->CalculateTarget()->GetPreferDynamicValue();
1327        options.SetFetchDynamicValue (fetch_dynamic_value);
1328        options.SetUnwindOnError (true);
1329        return EvaluateExpression (expr, options);
1330    }
1331    return result;
1332}
1333
1334SBValue
1335SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value)
1336{
1337    SBExpressionOptions options;
1338    options.SetFetchDynamicValue (fetch_dynamic_value);
1339    options.SetUnwindOnError (true);
1340    return EvaluateExpression (expr, options);
1341}
1342
1343SBValue
1344SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value, bool unwind_on_error)
1345{
1346    SBExpressionOptions options;
1347    options.SetFetchDynamicValue (fetch_dynamic_value);
1348    options.SetUnwindOnError (unwind_on_error);
1349    return EvaluateExpression (expr, options);
1350}
1351
1352lldb::SBValue
1353SBFrame::EvaluateExpression (const char *expr, const SBExpressionOptions &options)
1354{
1355    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1356
1357    Log *expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1358
1359    ExecutionResults exe_results = eExecutionSetupError;
1360    SBValue expr_result;
1361
1362    if (expr == NULL || expr[0] == '\0')
1363    {
1364        if (log)
1365            log->Printf ("SBFrame::EvaluateExpression called with an empty expression");
1366        return expr_result;
1367    }
1368
1369    ValueObjectSP expr_value_sp;
1370
1371    Mutex::Locker api_locker;
1372    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1373
1374    if (log)
1375        log->Printf ("SBFrame()::EvaluateExpression (expr=\"%s\")...", expr);
1376
1377    StackFrame *frame = NULL;
1378    Target *target = exe_ctx.GetTargetPtr();
1379    Process *process = exe_ctx.GetProcessPtr();
1380
1381    if (target && process)
1382    {
1383        Process::StopLocker stop_locker;
1384        if (stop_locker.TryLock(&process->GetRunLock()))
1385        {
1386            frame = exe_ctx.GetFramePtr();
1387            if (frame)
1388            {
1389#ifdef LLDB_CONFIGURATION_DEBUG
1390                StreamString frame_description;
1391                frame->DumpUsingSettingsFormat (&frame_description);
1392                Host::SetCrashDescriptionWithFormat ("SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s",
1393                                                     expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str());
1394#endif
1395                exe_results = target->EvaluateExpression (expr,
1396                                                          frame,
1397                                                          expr_value_sp,
1398                                                          options.ref());
1399                expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
1400#ifdef LLDB_CONFIGURATION_DEBUG
1401                Host::SetCrashDescription (NULL);
1402#endif
1403            }
1404            else
1405            {
1406                if (log)
1407                    log->Printf ("SBFrame::EvaluateExpression () => error: could not reconstruct frame object for this SBFrame.");
1408            }
1409        }
1410        else
1411        {
1412            if (log)
1413                log->Printf ("SBFrame::EvaluateExpression () => error: process is running");
1414        }
1415    }
1416
1417#ifndef LLDB_DISABLE_PYTHON
1418    if (expr_log)
1419        expr_log->Printf("** [SBFrame::EvaluateExpression] Expression result is %s, summary %s **",
1420                         expr_result.GetValue(),
1421                         expr_result.GetSummary());
1422
1423    if (log)
1424        log->Printf ("SBFrame(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) (execution result=%d)",
1425                     frame,
1426                     expr,
1427                     expr_value_sp.get(),
1428                     exe_results);
1429#endif
1430
1431    return expr_result;
1432}
1433
1434bool
1435SBFrame::IsInlined()
1436{
1437    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1438    ExecutionContext exe_ctx(m_opaque_sp.get());
1439    StackFrame *frame = NULL;
1440    Target *target = exe_ctx.GetTargetPtr();
1441    Process *process = exe_ctx.GetProcessPtr();
1442    if (target && process)
1443    {
1444        Process::StopLocker stop_locker;
1445        if (stop_locker.TryLock(&process->GetRunLock()))
1446        {
1447            frame = exe_ctx.GetFramePtr();
1448            if (frame)
1449            {
1450
1451                Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
1452                if (block)
1453                    return block->GetContainingInlinedBlock () != NULL;
1454            }
1455            else
1456            {
1457                if (log)
1458                    log->Printf ("SBFrame::IsInlined () => error: could not reconstruct frame object for this SBFrame.");
1459            }
1460        }
1461        else
1462        {
1463            if (log)
1464                log->Printf ("SBFrame::IsInlined () => error: process is running");
1465        }
1466
1467    }
1468    return false;
1469}
1470
1471const char *
1472SBFrame::GetFunctionName()
1473{
1474    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1475    const char *name = NULL;
1476    ExecutionContext exe_ctx(m_opaque_sp.get());
1477    StackFrame *frame = NULL;
1478    Target *target = exe_ctx.GetTargetPtr();
1479    Process *process = exe_ctx.GetProcessPtr();
1480    if (target && process)
1481    {
1482        Process::StopLocker stop_locker;
1483        if (stop_locker.TryLock(&process->GetRunLock()))
1484        {
1485            frame = exe_ctx.GetFramePtr();
1486            if (frame)
1487            {
1488                SymbolContext sc (frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol));
1489                if (sc.block)
1490                {
1491                    Block *inlined_block = sc.block->GetContainingInlinedBlock ();
1492                    if (inlined_block)
1493                    {
1494                        const InlineFunctionInfo* inlined_info = inlined_block->GetInlinedFunctionInfo();
1495                        name = inlined_info->GetName().AsCString();
1496                    }
1497                }
1498
1499                if (name == NULL)
1500                {
1501                    if (sc.function)
1502                        name = sc.function->GetName().GetCString();
1503                }
1504
1505                if (name == NULL)
1506                {
1507                    if (sc.symbol)
1508                        name = sc.symbol->GetName().GetCString();
1509                }
1510            }
1511            else
1512            {
1513                if (log)
1514                    log->Printf ("SBFrame::GetFunctionName () => error: could not reconstruct frame object for this SBFrame.");
1515            }
1516        }
1517        else
1518        {
1519            if (log)
1520                log->Printf ("SBFrame::GetFunctionName() => error: process is running");
1521
1522        }
1523    }
1524    return name;
1525}
1526
1527