SBFrame.cpp revision 269024 
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                VariableList variable_list;
849
850                switch (value_type)
851                {
852                case eValueTypeVariableGlobal:      // global variable
853                case eValueTypeVariableStatic:      // static variable
854                case eValueTypeVariableArgument:    // function argument variables
855                case eValueTypeVariableLocal:       // function local variables
856                    {
857
858                        SymbolContext sc (frame->GetSymbolContext (eSymbolContextBlock));
859
860                        const bool can_create = true;
861                        const bool get_parent_variables = true;
862                        const bool stop_if_block_is_inlined_function = true;
863
864                        if (sc.block && sc.block->AppendVariables (can_create,
865                                                                   get_parent_variables,
866                                                                   stop_if_block_is_inlined_function,
867                                                                   &variable_list))
868                        {
869                            if (value_type == eValueTypeVariableGlobal)
870                            {
871                                const bool get_file_globals = true;
872                                VariableList* frame_vars = frame->GetVariableList(get_file_globals);
873                                if (frame_vars)
874                                    frame_vars->AppendVariablesIfUnique(variable_list);
875                            }
876                            ConstString const_name(name);
877                            VariableSP variable_sp(variable_list.FindVariable(const_name,value_type));
878                            if (variable_sp)
879                            {
880                                value_sp = frame->GetValueObjectForFrameVariable (variable_sp, eNoDynamicValues);
881                                sb_value.SetSP (value_sp, use_dynamic);
882                                break;
883                            }
884                        }
885                    }
886                    break;
887
888                case eValueTypeRegister:            // stack frame register value
889                    {
890                        RegisterContextSP reg_ctx (frame->GetRegisterContext());
891                        if (reg_ctx)
892                        {
893                            const uint32_t num_regs = reg_ctx->GetRegisterCount();
894                            for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
895                            {
896                                const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx);
897                                if (reg_info &&
898                                    ((reg_info->name && strcasecmp (reg_info->name, name) == 0) ||
899                                     (reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0)))
900                                {
901                                    value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx);
902                                    sb_value.SetSP (value_sp);
903                                    break;
904                                }
905                            }
906                        }
907                    }
908                    break;
909
910                case eValueTypeRegisterSet:         // A collection of stack frame register values
911                    {
912                        RegisterContextSP reg_ctx (frame->GetRegisterContext());
913                        if (reg_ctx)
914                        {
915                            const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
916                            for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
917                            {
918                                const RegisterSet *reg_set = reg_ctx->GetRegisterSet (set_idx);
919                                if (reg_set &&
920                                    ((reg_set->name && strcasecmp (reg_set->name, name) == 0) ||
921                                     (reg_set->short_name && strcasecmp (reg_set->short_name, name) == 0)))
922                                {
923                                    value_sp = ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx);
924                                    sb_value.SetSP (value_sp);
925                                    break;
926                                }
927                            }
928                        }
929                    }
930                    break;
931
932                case eValueTypeConstResult:         // constant result variables
933                    {
934                        ConstString const_name(name);
935                        ClangExpressionVariableSP expr_var_sp (target->GetPersistentVariables().GetVariable (const_name));
936                        if (expr_var_sp)
937                        {
938                            value_sp = expr_var_sp->GetValueObject();
939                            sb_value.SetSP (value_sp, use_dynamic);
940                        }
941                    }
942                    break;
943
944                default:
945                    break;
946                }
947            }
948            else
949            {
950                if (log)
951                    log->Printf ("SBFrame::FindValue () => error: could not reconstruct frame object for this SBFrame.");
952            }
953        }
954        else
955        {
956            if (log)
957                log->Printf ("SBFrame::FindValue () => error: process is running");
958        }
959    }
960
961    if (log)
962        log->Printf ("SBFrame(%p)::FindVariableInScope (name=\"%s\", value_type=%i) => SBValue(%p)",
963                     frame, name, value_type, value_sp.get());
964
965
966    return sb_value;
967}
968
969bool
970SBFrame::IsEqual (const SBFrame &that) const
971{
972    lldb::StackFrameSP this_sp = GetFrameSP();
973    lldb::StackFrameSP that_sp = that.GetFrameSP();
974    return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
975}
976
977bool
978SBFrame::operator == (const SBFrame &rhs) const
979{
980    return IsEqual(rhs);
981}
982
983bool
984SBFrame::operator != (const SBFrame &rhs) const
985{
986    return !IsEqual(rhs);
987}
988
989SBThread
990SBFrame::GetThread () const
991{
992    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
993
994    ExecutionContext exe_ctx(m_opaque_sp.get());
995    ThreadSP thread_sp (exe_ctx.GetThreadSP());
996    SBThread sb_thread (thread_sp);
997
998    if (log)
999    {
1000        SBStream sstr;
1001        sb_thread.GetDescription (sstr);
1002        log->Printf ("SBFrame(%p)::GetThread () => SBThread(%p): %s",
1003                     exe_ctx.GetFramePtr(),
1004                     thread_sp.get(),
1005                     sstr.GetData());
1006    }
1007
1008    return sb_thread;
1009}
1010
1011const char *
1012SBFrame::Disassemble () const
1013{
1014    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1015    const char *disassembly = NULL;
1016    Mutex::Locker api_locker;
1017    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1018
1019    StackFrame *frame = NULL;
1020    Target *target = exe_ctx.GetTargetPtr();
1021    Process *process = exe_ctx.GetProcessPtr();
1022    if (target && process)
1023    {
1024        Process::StopLocker stop_locker;
1025        if (stop_locker.TryLock(&process->GetRunLock()))
1026        {
1027            frame = exe_ctx.GetFramePtr();
1028            if (frame)
1029            {
1030                disassembly = frame->Disassemble();
1031            }
1032            else
1033            {
1034                if (log)
1035                    log->Printf ("SBFrame::Disassemble () => error: could not reconstruct frame object for this SBFrame.");
1036            }
1037        }
1038        else
1039        {
1040            if (log)
1041                log->Printf ("SBFrame::Disassemble () => error: process is running");
1042        }
1043    }
1044
1045    if (log)
1046        log->Printf ("SBFrame(%p)::Disassemble () => %s", frame, disassembly);
1047
1048    return disassembly;
1049}
1050
1051
1052SBValueList
1053SBFrame::GetVariables (bool arguments,
1054                       bool locals,
1055                       bool statics,
1056                       bool in_scope_only)
1057{
1058    SBValueList value_list;
1059    ExecutionContext exe_ctx(m_opaque_sp.get());
1060    StackFrame *frame = exe_ctx.GetFramePtr();
1061    Target *target = exe_ctx.GetTargetPtr();
1062    if (frame && target)
1063    {
1064        lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
1065        value_list = GetVariables (arguments, locals, statics, in_scope_only, use_dynamic);
1066    }
1067    return value_list;
1068}
1069
1070SBValueList
1071SBFrame::GetVariables (bool arguments,
1072                       bool locals,
1073                       bool statics,
1074                       bool in_scope_only,
1075                       lldb::DynamicValueType  use_dynamic)
1076{
1077    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1078
1079    SBValueList value_list;
1080    Mutex::Locker api_locker;
1081    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1082
1083    StackFrame *frame = NULL;
1084    Target *target = exe_ctx.GetTargetPtr();
1085
1086    if (log)
1087        log->Printf ("SBFrame::GetVariables (arguments=%i, locals=%i, statics=%i, in_scope_only=%i)",
1088                     arguments,
1089                     locals,
1090                     statics,
1091                     in_scope_only);
1092
1093    Process *process = exe_ctx.GetProcessPtr();
1094    if (target && process)
1095    {
1096        Process::StopLocker stop_locker;
1097        if (stop_locker.TryLock(&process->GetRunLock()))
1098        {
1099            frame = exe_ctx.GetFramePtr();
1100            if (frame)
1101            {
1102                size_t i;
1103                VariableList *variable_list = NULL;
1104                variable_list = frame->GetVariableList(true);
1105                if (variable_list)
1106                {
1107                    const size_t num_variables = variable_list->GetSize();
1108                    if (num_variables)
1109                    {
1110                        for (i = 0; i < num_variables; ++i)
1111                        {
1112                            VariableSP variable_sp (variable_list->GetVariableAtIndex(i));
1113                            if (variable_sp)
1114                            {
1115                                bool add_variable = false;
1116                                switch (variable_sp->GetScope())
1117                                {
1118                                case eValueTypeVariableGlobal:
1119                                case eValueTypeVariableStatic:
1120                                    add_variable = statics;
1121                                    break;
1122
1123                                case eValueTypeVariableArgument:
1124                                    add_variable = arguments;
1125                                    break;
1126
1127                                case eValueTypeVariableLocal:
1128                                    add_variable = locals;
1129                                    break;
1130
1131                                default:
1132                                    break;
1133                                }
1134                                if (add_variable)
1135                                {
1136                                    if (in_scope_only && !variable_sp->IsInScope(frame))
1137                                        continue;
1138
1139                                    ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable (variable_sp, eNoDynamicValues));
1140                                    SBValue value_sb;
1141                                    value_sb.SetSP(valobj_sp,use_dynamic);
1142                                    value_list.Append(value_sb);
1143                                }
1144                            }
1145                        }
1146                    }
1147                }
1148            }
1149            else
1150            {
1151                if (log)
1152                    log->Printf ("SBFrame::GetVariables () => error: could not reconstruct frame object for this SBFrame.");
1153            }
1154        }
1155        else
1156        {
1157            if (log)
1158                log->Printf ("SBFrame::GetVariables () => error: process is running");
1159        }
1160    }
1161
1162    if (log)
1163    {
1164        log->Printf ("SBFrame(%p)::GetVariables (...) => SBValueList(%p)", frame, value_list.opaque_ptr());
1165    }
1166
1167    return value_list;
1168}
1169
1170SBValueList
1171SBFrame::GetRegisters ()
1172{
1173    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1174
1175    SBValueList value_list;
1176    Mutex::Locker api_locker;
1177    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1178
1179    StackFrame *frame = NULL;
1180    Target *target = exe_ctx.GetTargetPtr();
1181    Process *process = exe_ctx.GetProcessPtr();
1182    if (target && process)
1183    {
1184        Process::StopLocker stop_locker;
1185        if (stop_locker.TryLock(&process->GetRunLock()))
1186        {
1187            frame = exe_ctx.GetFramePtr();
1188            if (frame)
1189            {
1190                RegisterContextSP reg_ctx (frame->GetRegisterContext());
1191                if (reg_ctx)
1192                {
1193                    const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
1194                    for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
1195                    {
1196                        value_list.Append(ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx));
1197                    }
1198                }
1199            }
1200            else
1201            {
1202                if (log)
1203                    log->Printf ("SBFrame::GetRegisters () => error: could not reconstruct frame object for this SBFrame.");
1204            }
1205        }
1206        else
1207        {
1208            if (log)
1209                log->Printf ("SBFrame::GetRegisters () => error: process is running");
1210        }
1211    }
1212
1213    if (log)
1214        log->Printf ("SBFrame(%p)::GetRegisters () => SBValueList(%p)", frame, value_list.opaque_ptr());
1215
1216    return value_list;
1217}
1218
1219SBValue
1220SBFrame::FindRegister (const char *name)
1221{
1222    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1223
1224    SBValue result;
1225    ValueObjectSP value_sp;
1226    Mutex::Locker api_locker;
1227    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1228
1229    StackFrame *frame = NULL;
1230    Target *target = exe_ctx.GetTargetPtr();
1231    Process *process = exe_ctx.GetProcessPtr();
1232    if (target && process)
1233    {
1234        Process::StopLocker stop_locker;
1235        if (stop_locker.TryLock(&process->GetRunLock()))
1236        {
1237            frame = exe_ctx.GetFramePtr();
1238            if (frame)
1239            {
1240                RegisterContextSP reg_ctx (frame->GetRegisterContext());
1241                if (reg_ctx)
1242                {
1243                    const uint32_t num_regs = reg_ctx->GetRegisterCount();
1244                    for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
1245                    {
1246                        const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx);
1247                        if (reg_info &&
1248                            ((reg_info->name && strcasecmp (reg_info->name, name) == 0) ||
1249                             (reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0)))
1250                        {
1251                            value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx);
1252                            result.SetSP (value_sp);
1253                            break;
1254                        }
1255                    }
1256                }
1257            }
1258            else
1259            {
1260                if (log)
1261                    log->Printf ("SBFrame::FindRegister () => error: could not reconstruct frame object for this SBFrame.");
1262            }
1263        }
1264        else
1265        {
1266            if (log)
1267                log->Printf ("SBFrame::FindRegister () => error: process is running");
1268        }
1269    }
1270
1271    if (log)
1272        log->Printf ("SBFrame(%p)::FindRegister () => SBValue(%p)", frame, value_sp.get());
1273
1274    return result;
1275}
1276
1277bool
1278SBFrame::GetDescription (SBStream &description)
1279{
1280    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1281    Stream &strm = description.ref();
1282
1283    Mutex::Locker api_locker;
1284    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1285
1286    StackFrame *frame;
1287    Target *target = exe_ctx.GetTargetPtr();
1288    Process *process = exe_ctx.GetProcessPtr();
1289    if (target && process)
1290    {
1291        Process::StopLocker stop_locker;
1292        if (stop_locker.TryLock(&process->GetRunLock()))
1293        {
1294            frame = exe_ctx.GetFramePtr();
1295            if (frame)
1296            {
1297                frame->DumpUsingSettingsFormat (&strm);
1298            }
1299            else
1300            {
1301                if (log)
1302                    log->Printf ("SBFrame::GetDescription () => error: could not reconstruct frame object for this SBFrame.");
1303            }
1304        }
1305        else
1306        {
1307            if (log)
1308                log->Printf ("SBFrame::GetDescription () => error: process is running");
1309        }
1310
1311    }
1312    else
1313        strm.PutCString ("No value");
1314
1315    return true;
1316}
1317
1318SBValue
1319SBFrame::EvaluateExpression (const char *expr)
1320{
1321    SBValue result;
1322    ExecutionContext exe_ctx(m_opaque_sp.get());
1323    StackFrame *frame = exe_ctx.GetFramePtr();
1324    Target *target = exe_ctx.GetTargetPtr();
1325    if (frame && target)
1326    {
1327        SBExpressionOptions options;
1328        lldb::DynamicValueType fetch_dynamic_value = frame->CalculateTarget()->GetPreferDynamicValue();
1329        options.SetFetchDynamicValue (fetch_dynamic_value);
1330        options.SetUnwindOnError (true);
1331        return EvaluateExpression (expr, options);
1332    }
1333    return result;
1334}
1335
1336SBValue
1337SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value)
1338{
1339    SBExpressionOptions options;
1340    options.SetFetchDynamicValue (fetch_dynamic_value);
1341    options.SetUnwindOnError (true);
1342    return EvaluateExpression (expr, options);
1343}
1344
1345SBValue
1346SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value, bool unwind_on_error)
1347{
1348    SBExpressionOptions options;
1349    options.SetFetchDynamicValue (fetch_dynamic_value);
1350    options.SetUnwindOnError (unwind_on_error);
1351    return EvaluateExpression (expr, options);
1352}
1353
1354lldb::SBValue
1355SBFrame::EvaluateExpression (const char *expr, const SBExpressionOptions &options)
1356{
1357    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1358
1359    Log *expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1360
1361    ExecutionResults exe_results = eExecutionSetupError;
1362    SBValue expr_result;
1363
1364    if (expr == NULL || expr[0] == '\0')
1365    {
1366        if (log)
1367            log->Printf ("SBFrame::EvaluateExpression called with an empty expression");
1368        return expr_result;
1369    }
1370
1371    ValueObjectSP expr_value_sp;
1372
1373    Mutex::Locker api_locker;
1374    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
1375
1376    if (log)
1377        log->Printf ("SBFrame()::EvaluateExpression (expr=\"%s\")...", expr);
1378
1379    StackFrame *frame = NULL;
1380    Target *target = exe_ctx.GetTargetPtr();
1381    Process *process = exe_ctx.GetProcessPtr();
1382
1383    if (target && process)
1384    {
1385        Process::StopLocker stop_locker;
1386        if (stop_locker.TryLock(&process->GetRunLock()))
1387        {
1388            frame = exe_ctx.GetFramePtr();
1389            if (frame)
1390            {
1391                if (target->GetDisplayExpressionsInCrashlogs())
1392                {
1393                    StreamString frame_description;
1394                    frame->DumpUsingSettingsFormat (&frame_description);
1395                    Host::SetCrashDescriptionWithFormat ("SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s",
1396                                                         expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str());
1397                }
1398
1399                exe_results = target->EvaluateExpression (expr,
1400                                                          frame,
1401                                                          expr_value_sp,
1402                                                          options.ref());
1403                expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
1404
1405                if (target->GetDisplayExpressionsInCrashlogs())
1406                    Host::SetCrashDescription (NULL);
1407            }
1408            else
1409            {
1410                if (log)
1411                    log->Printf ("SBFrame::EvaluateExpression () => error: could not reconstruct frame object for this SBFrame.");
1412            }
1413        }
1414        else
1415        {
1416            if (log)
1417                log->Printf ("SBFrame::EvaluateExpression () => error: process is running");
1418        }
1419    }
1420
1421#ifndef LLDB_DISABLE_PYTHON
1422    if (expr_log)
1423        expr_log->Printf("** [SBFrame::EvaluateExpression] Expression result is %s, summary %s **",
1424                         expr_result.GetValue(),
1425                         expr_result.GetSummary());
1426
1427    if (log)
1428        log->Printf ("SBFrame(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) (execution result=%d)",
1429                     frame,
1430                     expr,
1431                     expr_value_sp.get(),
1432                     exe_results);
1433#endif
1434
1435    return expr_result;
1436}
1437
1438bool
1439SBFrame::IsInlined()
1440{
1441    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1442    ExecutionContext exe_ctx(m_opaque_sp.get());
1443    StackFrame *frame = NULL;
1444    Target *target = exe_ctx.GetTargetPtr();
1445    Process *process = exe_ctx.GetProcessPtr();
1446    if (target && process)
1447    {
1448        Process::StopLocker stop_locker;
1449        if (stop_locker.TryLock(&process->GetRunLock()))
1450        {
1451            frame = exe_ctx.GetFramePtr();
1452            if (frame)
1453            {
1454
1455                Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
1456                if (block)
1457                    return block->GetContainingInlinedBlock () != NULL;
1458            }
1459            else
1460            {
1461                if (log)
1462                    log->Printf ("SBFrame::IsInlined () => error: could not reconstruct frame object for this SBFrame.");
1463            }
1464        }
1465        else
1466        {
1467            if (log)
1468                log->Printf ("SBFrame::IsInlined () => error: process is running");
1469        }
1470
1471    }
1472    return false;
1473}
1474
1475const char *
1476SBFrame::GetFunctionName()
1477{
1478    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1479    const char *name = NULL;
1480    ExecutionContext exe_ctx(m_opaque_sp.get());
1481    StackFrame *frame = NULL;
1482    Target *target = exe_ctx.GetTargetPtr();
1483    Process *process = exe_ctx.GetProcessPtr();
1484    if (target && process)
1485    {
1486        Process::StopLocker stop_locker;
1487        if (stop_locker.TryLock(&process->GetRunLock()))
1488        {
1489            frame = exe_ctx.GetFramePtr();
1490            if (frame)
1491            {
1492                SymbolContext sc (frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol));
1493                if (sc.block)
1494                {
1495                    Block *inlined_block = sc.block->GetContainingInlinedBlock ();
1496                    if (inlined_block)
1497                    {
1498                        const InlineFunctionInfo* inlined_info = inlined_block->GetInlinedFunctionInfo();
1499                        name = inlined_info->GetName().AsCString();
1500                    }
1501                }
1502
1503                if (name == NULL)
1504                {
1505                    if (sc.function)
1506                        name = sc.function->GetName().GetCString();
1507                }
1508
1509                if (name == NULL)
1510                {
1511                    if (sc.symbol)
1512                        name = sc.symbol->GetName().GetCString();
1513                }
1514            }
1515            else
1516            {
1517                if (log)
1518                    log->Printf ("SBFrame::GetFunctionName () => error: could not reconstruct frame object for this SBFrame.");
1519            }
1520        }
1521        else
1522        {
1523            if (log)
1524                log->Printf ("SBFrame::GetFunctionName() => error: process is running");
1525
1526        }
1527    }
1528    return name;
1529}
1530
1531