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