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