xref: /freebsd/contrib/llvm-project/lldb/source/API/SBFrame.cpp (revision 5def4c47d4bd90b209b9b4a4ba9faec15846d8fd) 
1 //===-- SBFrame.cpp -------------------------------------------------------===//
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   Target *target = exe_ctx.GetTargetPtr();
358   Process *process = exe_ctx.GetProcessPtr();
359   if (target && process) {
360     Process::StopLocker stop_locker;
361     if (stop_locker.TryLock(&process->GetRunLock())) {
362       if (StackFrame *frame = exe_ctx.GetFramePtr()) {
363         if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
364           ret_val = reg_ctx_sp->SetPC(new_pc);
365         }
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   Target *target = exe_ctx.GetTargetPtr();
381   Process *process = exe_ctx.GetProcessPtr();
382   if (target && process) {
383     Process::StopLocker stop_locker;
384     if (stop_locker.TryLock(&process->GetRunLock())) {
385       if (StackFrame *frame = exe_ctx.GetFramePtr()) {
386         if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
387           addr = reg_ctx_sp->GetSP();
388         }
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   Target *target = exe_ctx.GetTargetPtr();
404   Process *process = exe_ctx.GetProcessPtr();
405   if (target && process) {
406     Process::StopLocker stop_locker;
407     if (stop_locker.TryLock(&process->GetRunLock())) {
408       if (StackFrame *frame = exe_ctx.GetFramePtr()) {
409         if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
410           addr = reg_ctx_sp->GetFP();
411         }
412       }
413     }
414   }
415 
416   return addr;
417 }
418 
419 SBAddress SBFrame::GetPCAddress() const {
420   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
421 
422   SBAddress sb_addr;
423   std::unique_lock<std::recursive_mutex> lock;
424   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
425 
426   StackFrame *frame = exe_ctx.GetFramePtr();
427   Target *target = exe_ctx.GetTargetPtr();
428   Process *process = exe_ctx.GetProcessPtr();
429   if (target && process) {
430     Process::StopLocker stop_locker;
431     if (stop_locker.TryLock(&process->GetRunLock())) {
432       frame = exe_ctx.GetFramePtr();
433       if (frame)
434         sb_addr.SetAddress(frame->GetFrameCodeAddress());
435     }
436   }
437   return LLDB_RECORD_RESULT(sb_addr);
438 }
439 
440 void SBFrame::Clear() {
441   LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
442 
443   m_opaque_sp->Clear();
444 }
445 
446 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
447   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
448                      (const char *), var_path);
449 
450   SBValue sb_value;
451   std::unique_lock<std::recursive_mutex> lock;
452   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
453 
454   StackFrame *frame = exe_ctx.GetFramePtr();
455   Target *target = exe_ctx.GetTargetPtr();
456   if (frame && target) {
457     lldb::DynamicValueType use_dynamic =
458         frame->CalculateTarget()->GetPreferDynamicValue();
459     sb_value = GetValueForVariablePath(var_path, use_dynamic);
460   }
461   return LLDB_RECORD_RESULT(sb_value);
462 }
463 
464 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
465                                                DynamicValueType use_dynamic) {
466   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
467                      (const char *, lldb::DynamicValueType), var_path,
468                      use_dynamic);
469 
470   SBValue sb_value;
471   if (var_path == nullptr || var_path[0] == '\0') {
472     return LLDB_RECORD_RESULT(sb_value);
473   }
474 
475   std::unique_lock<std::recursive_mutex> lock;
476   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
477 
478   StackFrame *frame = nullptr;
479   Target *target = exe_ctx.GetTargetPtr();
480   Process *process = exe_ctx.GetProcessPtr();
481   if (target && process) {
482     Process::StopLocker stop_locker;
483     if (stop_locker.TryLock(&process->GetRunLock())) {
484       frame = exe_ctx.GetFramePtr();
485       if (frame) {
486         VariableSP var_sp;
487         Status error;
488         ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
489             var_path, eNoDynamicValues,
490             StackFrame::eExpressionPathOptionCheckPtrVsMember |
491                 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
492             var_sp, error));
493         sb_value.SetSP(value_sp, use_dynamic);
494       }
495     }
496   }
497   return LLDB_RECORD_RESULT(sb_value);
498 }
499 
500 SBValue SBFrame::FindVariable(const char *name) {
501   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
502                      name);
503 
504   SBValue value;
505   std::unique_lock<std::recursive_mutex> lock;
506   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
507 
508   StackFrame *frame = exe_ctx.GetFramePtr();
509   Target *target = exe_ctx.GetTargetPtr();
510   if (frame && target) {
511     lldb::DynamicValueType use_dynamic =
512         frame->CalculateTarget()->GetPreferDynamicValue();
513     value = FindVariable(name, use_dynamic);
514   }
515   return LLDB_RECORD_RESULT(value);
516 }
517 
518 SBValue SBFrame::FindVariable(const char *name,
519                               lldb::DynamicValueType use_dynamic) {
520   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
521                      (const char *, lldb::DynamicValueType), name, use_dynamic);
522 
523   VariableSP var_sp;
524   SBValue sb_value;
525 
526   if (name == nullptr || name[0] == '\0') {
527     return LLDB_RECORD_RESULT(sb_value);
528   }
529 
530   ValueObjectSP value_sp;
531   std::unique_lock<std::recursive_mutex> lock;
532   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
533 
534   StackFrame *frame = nullptr;
535   Target *target = exe_ctx.GetTargetPtr();
536   Process *process = exe_ctx.GetProcessPtr();
537   if (target && process) {
538     Process::StopLocker stop_locker;
539     if (stop_locker.TryLock(&process->GetRunLock())) {
540       frame = exe_ctx.GetFramePtr();
541       if (frame) {
542         value_sp = frame->FindVariable(ConstString(name));
543 
544         if (value_sp)
545           sb_value.SetSP(value_sp, use_dynamic);
546       }
547     }
548   }
549 
550   return LLDB_RECORD_RESULT(sb_value);
551 }
552 
553 SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
554   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
555                      (const char *, lldb::ValueType), name, value_type);
556 
557   SBValue value;
558   std::unique_lock<std::recursive_mutex> lock;
559   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
560 
561   StackFrame *frame = exe_ctx.GetFramePtr();
562   Target *target = exe_ctx.GetTargetPtr();
563   if (frame && target) {
564     lldb::DynamicValueType use_dynamic =
565         frame->CalculateTarget()->GetPreferDynamicValue();
566     value = FindValue(name, value_type, use_dynamic);
567   }
568   return LLDB_RECORD_RESULT(value);
569 }
570 
571 SBValue SBFrame::FindValue(const char *name, ValueType value_type,
572                            lldb::DynamicValueType use_dynamic) {
573   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
574                      (const char *, lldb::ValueType, lldb::DynamicValueType),
575                      name, value_type, use_dynamic);
576 
577   SBValue sb_value;
578 
579   if (name == nullptr || name[0] == '\0') {
580     return LLDB_RECORD_RESULT(sb_value);
581   }
582 
583   ValueObjectSP value_sp;
584   std::unique_lock<std::recursive_mutex> lock;
585   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
586 
587   StackFrame *frame = nullptr;
588   Target *target = exe_ctx.GetTargetPtr();
589   Process *process = exe_ctx.GetProcessPtr();
590   if (target && process) {
591     Process::StopLocker stop_locker;
592     if (stop_locker.TryLock(&process->GetRunLock())) {
593       frame = exe_ctx.GetFramePtr();
594       if (frame) {
595         VariableList variable_list;
596 
597         switch (value_type) {
598         case eValueTypeVariableGlobal:      // global variable
599         case eValueTypeVariableStatic:      // static variable
600         case eValueTypeVariableArgument:    // function argument variables
601         case eValueTypeVariableLocal:       // function local variables
602         case eValueTypeVariableThreadLocal: // thread local variables
603         {
604           SymbolContext sc(frame->GetSymbolContext(eSymbolContextBlock));
605 
606           const bool can_create = true;
607           const bool get_parent_variables = true;
608           const bool stop_if_block_is_inlined_function = true;
609 
610           if (sc.block)
611             sc.block->AppendVariables(
612                 can_create, get_parent_variables,
613                 stop_if_block_is_inlined_function,
614                 [frame](Variable *v) { return v->IsInScope(frame); },
615                 &variable_list);
616           if (value_type == eValueTypeVariableGlobal) {
617             const bool get_file_globals = true;
618             VariableList *frame_vars = frame->GetVariableList(get_file_globals);
619             if (frame_vars)
620               frame_vars->AppendVariablesIfUnique(variable_list);
621           }
622           ConstString const_name(name);
623           VariableSP variable_sp(
624               variable_list.FindVariable(const_name, value_type));
625           if (variable_sp) {
626             value_sp = frame->GetValueObjectForFrameVariable(variable_sp,
627                                                              eNoDynamicValues);
628             sb_value.SetSP(value_sp, use_dynamic);
629           }
630         } break;
631 
632         case eValueTypeRegister: // stack frame register value
633         {
634           RegisterContextSP reg_ctx(frame->GetRegisterContext());
635           if (reg_ctx) {
636             const uint32_t num_regs = reg_ctx->GetRegisterCount();
637             for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
638               const RegisterInfo *reg_info =
639                   reg_ctx->GetRegisterInfoAtIndex(reg_idx);
640               if (reg_info &&
641                   ((reg_info->name && strcasecmp(reg_info->name, name) == 0) ||
642                    (reg_info->alt_name &&
643                     strcasecmp(reg_info->alt_name, name) == 0))) {
644                 value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
645                 sb_value.SetSP(value_sp);
646                 break;
647               }
648             }
649           }
650         } break;
651 
652         case eValueTypeRegisterSet: // A collection of stack frame register
653                                     // values
654         {
655           RegisterContextSP reg_ctx(frame->GetRegisterContext());
656           if (reg_ctx) {
657             const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
658             for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
659               const RegisterSet *reg_set = reg_ctx->GetRegisterSet(set_idx);
660               if (reg_set &&
661                   ((reg_set->name && strcasecmp(reg_set->name, name) == 0) ||
662                    (reg_set->short_name &&
663                     strcasecmp(reg_set->short_name, name) == 0))) {
664                 value_sp =
665                     ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx);
666                 sb_value.SetSP(value_sp);
667                 break;
668               }
669             }
670           }
671         } break;
672 
673         case eValueTypeConstResult: // constant result variables
674         {
675           ConstString const_name(name);
676           ExpressionVariableSP expr_var_sp(
677               target->GetPersistentVariable(const_name));
678           if (expr_var_sp) {
679             value_sp = expr_var_sp->GetValueObject();
680             sb_value.SetSP(value_sp, use_dynamic);
681           }
682         } break;
683 
684         default:
685           break;
686         }
687       }
688     }
689   }
690 
691   return LLDB_RECORD_RESULT(sb_value);
692 }
693 
694 bool SBFrame::IsEqual(const SBFrame &that) const {
695   LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
696                            that);
697 
698   lldb::StackFrameSP this_sp = GetFrameSP();
699   lldb::StackFrameSP that_sp = that.GetFrameSP();
700   return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
701 }
702 
703 bool SBFrame::operator==(const SBFrame &rhs) const {
704   LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
705                            rhs);
706 
707   return IsEqual(rhs);
708 }
709 
710 bool SBFrame::operator!=(const SBFrame &rhs) const {
711   LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
712                            rhs);
713 
714   return !IsEqual(rhs);
715 }
716 
717 SBThread SBFrame::GetThread() const {
718   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
719 
720   std::unique_lock<std::recursive_mutex> lock;
721   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
722 
723   ThreadSP thread_sp(exe_ctx.GetThreadSP());
724   SBThread sb_thread(thread_sp);
725 
726   return LLDB_RECORD_RESULT(sb_thread);
727 }
728 
729 const char *SBFrame::Disassemble() const {
730   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
731 
732   const char *disassembly = nullptr;
733   std::unique_lock<std::recursive_mutex> lock;
734   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
735 
736   StackFrame *frame = nullptr;
737   Target *target = exe_ctx.GetTargetPtr();
738   Process *process = exe_ctx.GetProcessPtr();
739   if (target && process) {
740     Process::StopLocker stop_locker;
741     if (stop_locker.TryLock(&process->GetRunLock())) {
742       frame = exe_ctx.GetFramePtr();
743       if (frame) {
744         disassembly = frame->Disassemble();
745       }
746     }
747   }
748 
749   return disassembly;
750 }
751 
752 SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
753                                   bool in_scope_only) {
754   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
755                      (bool, bool, bool, bool), arguments, locals, statics,
756                      in_scope_only);
757 
758   SBValueList value_list;
759   std::unique_lock<std::recursive_mutex> lock;
760   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
761 
762   StackFrame *frame = exe_ctx.GetFramePtr();
763   Target *target = exe_ctx.GetTargetPtr();
764   if (frame && target) {
765     lldb::DynamicValueType use_dynamic =
766         frame->CalculateTarget()->GetPreferDynamicValue();
767     const bool include_runtime_support_values =
768         target ? target->GetDisplayRuntimeSupportValues() : false;
769 
770     SBVariablesOptions options;
771     options.SetIncludeArguments(arguments);
772     options.SetIncludeLocals(locals);
773     options.SetIncludeStatics(statics);
774     options.SetInScopeOnly(in_scope_only);
775     options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
776     options.SetUseDynamic(use_dynamic);
777 
778     value_list = GetVariables(options);
779   }
780   return LLDB_RECORD_RESULT(value_list);
781 }
782 
783 lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
784                                         bool statics, bool in_scope_only,
785                                         lldb::DynamicValueType use_dynamic) {
786   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
787                      (bool, bool, bool, bool, lldb::DynamicValueType),
788                      arguments, locals, statics, in_scope_only, use_dynamic);
789 
790   std::unique_lock<std::recursive_mutex> lock;
791   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
792 
793   Target *target = exe_ctx.GetTargetPtr();
794   const bool include_runtime_support_values =
795       target ? target->GetDisplayRuntimeSupportValues() : false;
796   SBVariablesOptions options;
797   options.SetIncludeArguments(arguments);
798   options.SetIncludeLocals(locals);
799   options.SetIncludeStatics(statics);
800   options.SetInScopeOnly(in_scope_only);
801   options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
802   options.SetUseDynamic(use_dynamic);
803   return LLDB_RECORD_RESULT(GetVariables(options));
804 }
805 
806 SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
807   LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
808                      (const lldb::SBVariablesOptions &), options);
809 
810   SBValueList value_list;
811   std::unique_lock<std::recursive_mutex> lock;
812   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
813 
814   StackFrame *frame = nullptr;
815   Target *target = exe_ctx.GetTargetPtr();
816 
817   const bool statics = options.GetIncludeStatics();
818   const bool arguments = options.GetIncludeArguments();
819   const bool recognized_arguments =
820         options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP()));
821   const bool locals = options.GetIncludeLocals();
822   const bool in_scope_only = options.GetInScopeOnly();
823   const bool include_runtime_support_values =
824       options.GetIncludeRuntimeSupportValues();
825   const lldb::DynamicValueType use_dynamic = options.GetUseDynamic();
826 
827 
828   std::set<VariableSP> variable_set;
829   Process *process = exe_ctx.GetProcessPtr();
830   if (target && process) {
831     Process::StopLocker stop_locker;
832     if (stop_locker.TryLock(&process->GetRunLock())) {
833       frame = exe_ctx.GetFramePtr();
834       if (frame) {
835         VariableList *variable_list = nullptr;
836         variable_list = frame->GetVariableList(true);
837         if (variable_list) {
838           const size_t num_variables = variable_list->GetSize();
839           if (num_variables) {
840             for (const VariableSP &variable_sp : *variable_list) {
841               if (variable_sp) {
842                 bool add_variable = false;
843                 switch (variable_sp->GetScope()) {
844                 case eValueTypeVariableGlobal:
845                 case eValueTypeVariableStatic:
846                 case eValueTypeVariableThreadLocal:
847                   add_variable = statics;
848                   break;
849 
850                 case eValueTypeVariableArgument:
851                   add_variable = arguments;
852                   break;
853 
854                 case eValueTypeVariableLocal:
855                   add_variable = locals;
856                   break;
857 
858                 default:
859                   break;
860                 }
861                 if (add_variable) {
862                   // Only add variables once so we don't end up with duplicates
863                   if (variable_set.find(variable_sp) == variable_set.end())
864                     variable_set.insert(variable_sp);
865                   else
866                     continue;
867 
868                   if (in_scope_only && !variable_sp->IsInScope(frame))
869                     continue;
870 
871                   ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable(
872                       variable_sp, eNoDynamicValues));
873 
874                   if (!include_runtime_support_values && valobj_sp != nullptr &&
875                       valobj_sp->IsRuntimeSupportValue())
876                     continue;
877 
878                   SBValue value_sb;
879                   value_sb.SetSP(valobj_sp, use_dynamic);
880                   value_list.Append(value_sb);
881                 }
882               }
883             }
884           }
885         }
886         if (recognized_arguments) {
887           auto recognized_frame = frame->GetRecognizedFrame();
888           if (recognized_frame) {
889             ValueObjectListSP recognized_arg_list =
890                 recognized_frame->GetRecognizedArguments();
891             if (recognized_arg_list) {
892               for (auto &rec_value_sp : recognized_arg_list->GetObjects()) {
893                 SBValue value_sb;
894                 value_sb.SetSP(rec_value_sp, use_dynamic);
895                 value_list.Append(value_sb);
896               }
897             }
898           }
899         }
900       }
901     }
902   }
903 
904   return LLDB_RECORD_RESULT(value_list);
905 }
906 
907 SBValueList SBFrame::GetRegisters() {
908   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
909 
910   SBValueList value_list;
911   std::unique_lock<std::recursive_mutex> lock;
912   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
913 
914   StackFrame *frame = nullptr;
915   Target *target = exe_ctx.GetTargetPtr();
916   Process *process = exe_ctx.GetProcessPtr();
917   if (target && process) {
918     Process::StopLocker stop_locker;
919     if (stop_locker.TryLock(&process->GetRunLock())) {
920       frame = exe_ctx.GetFramePtr();
921       if (frame) {
922         RegisterContextSP reg_ctx(frame->GetRegisterContext());
923         if (reg_ctx) {
924           const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
925           for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
926             value_list.Append(
927                 ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx));
928           }
929         }
930       }
931     }
932   }
933 
934   return LLDB_RECORD_RESULT(value_list);
935 }
936 
937 SBValue SBFrame::FindRegister(const char *name) {
938   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
939                      name);
940 
941   SBValue result;
942   ValueObjectSP value_sp;
943   std::unique_lock<std::recursive_mutex> lock;
944   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
945 
946   StackFrame *frame = nullptr;
947   Target *target = exe_ctx.GetTargetPtr();
948   Process *process = exe_ctx.GetProcessPtr();
949   if (target && process) {
950     Process::StopLocker stop_locker;
951     if (stop_locker.TryLock(&process->GetRunLock())) {
952       frame = exe_ctx.GetFramePtr();
953       if (frame) {
954         RegisterContextSP reg_ctx(frame->GetRegisterContext());
955         if (reg_ctx) {
956           const uint32_t num_regs = reg_ctx->GetRegisterCount();
957           for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
958             const RegisterInfo *reg_info =
959                 reg_ctx->GetRegisterInfoAtIndex(reg_idx);
960             if (reg_info &&
961                 ((reg_info->name && strcasecmp(reg_info->name, name) == 0) ||
962                  (reg_info->alt_name &&
963                   strcasecmp(reg_info->alt_name, name) == 0))) {
964               value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
965               result.SetSP(value_sp);
966               break;
967             }
968           }
969         }
970       }
971     }
972   }
973 
974   return LLDB_RECORD_RESULT(result);
975 }
976 
977 bool SBFrame::GetDescription(SBStream &description) {
978   LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
979                      description);
980 
981   Stream &strm = description.ref();
982 
983   std::unique_lock<std::recursive_mutex> lock;
984   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
985 
986   StackFrame *frame;
987   Target *target = exe_ctx.GetTargetPtr();
988   Process *process = exe_ctx.GetProcessPtr();
989   if (target && process) {
990     Process::StopLocker stop_locker;
991     if (stop_locker.TryLock(&process->GetRunLock())) {
992       frame = exe_ctx.GetFramePtr();
993       if (frame) {
994         frame->DumpUsingSettingsFormat(&strm);
995       }
996     }
997 
998   } else
999     strm.PutCString("No value");
1000 
1001   return true;
1002 }
1003 
1004 SBValue SBFrame::EvaluateExpression(const char *expr) {
1005   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
1006                      expr);
1007 
1008   SBValue result;
1009   std::unique_lock<std::recursive_mutex> lock;
1010   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1011 
1012   StackFrame *frame = exe_ctx.GetFramePtr();
1013   Target *target = exe_ctx.GetTargetPtr();
1014   if (frame && target) {
1015     SBExpressionOptions options;
1016     lldb::DynamicValueType fetch_dynamic_value =
1017         frame->CalculateTarget()->GetPreferDynamicValue();
1018     options.SetFetchDynamicValue(fetch_dynamic_value);
1019     options.SetUnwindOnError(true);
1020     options.SetIgnoreBreakpoints(true);
1021     if (target->GetLanguage() != eLanguageTypeUnknown)
1022       options.SetLanguage(target->GetLanguage());
1023     else
1024       options.SetLanguage(frame->GetLanguage());
1025     return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
1026   }
1027   return LLDB_RECORD_RESULT(result);
1028 }
1029 
1030 SBValue
1031 SBFrame::EvaluateExpression(const char *expr,
1032                             lldb::DynamicValueType fetch_dynamic_value) {
1033   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1034                      (const char *, lldb::DynamicValueType), expr,
1035                      fetch_dynamic_value);
1036 
1037   SBExpressionOptions options;
1038   options.SetFetchDynamicValue(fetch_dynamic_value);
1039   options.SetUnwindOnError(true);
1040   options.SetIgnoreBreakpoints(true);
1041   std::unique_lock<std::recursive_mutex> lock;
1042   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1043 
1044   StackFrame *frame = exe_ctx.GetFramePtr();
1045   Target *target = exe_ctx.GetTargetPtr();
1046   if (target && target->GetLanguage() != eLanguageTypeUnknown)
1047     options.SetLanguage(target->GetLanguage());
1048   else if (frame)
1049     options.SetLanguage(frame->GetLanguage());
1050   return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
1051 }
1052 
1053 SBValue SBFrame::EvaluateExpression(const char *expr,
1054                                     lldb::DynamicValueType fetch_dynamic_value,
1055                                     bool unwind_on_error) {
1056   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1057                      (const char *, lldb::DynamicValueType, bool), expr,
1058                      fetch_dynamic_value, unwind_on_error);
1059 
1060   SBExpressionOptions options;
1061   std::unique_lock<std::recursive_mutex> lock;
1062   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1063 
1064   options.SetFetchDynamicValue(fetch_dynamic_value);
1065   options.SetUnwindOnError(unwind_on_error);
1066   options.SetIgnoreBreakpoints(true);
1067   StackFrame *frame = exe_ctx.GetFramePtr();
1068   Target *target = exe_ctx.GetTargetPtr();
1069   if (target && target->GetLanguage() != eLanguageTypeUnknown)
1070     options.SetLanguage(target->GetLanguage());
1071   else if (frame)
1072     options.SetLanguage(frame->GetLanguage());
1073   return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
1074 }
1075 
1076 lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
1077                                           const SBExpressionOptions &options) {
1078   LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1079                      (const char *, const lldb::SBExpressionOptions &), expr,
1080                      options);
1081 
1082   Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1083 
1084   SBValue expr_result;
1085 
1086   if (expr == nullptr || expr[0] == '\0') {
1087     return LLDB_RECORD_RESULT(expr_result);
1088   }
1089 
1090   ValueObjectSP expr_value_sp;
1091 
1092   std::unique_lock<std::recursive_mutex> lock;
1093   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1094 
1095 
1096   StackFrame *frame = nullptr;
1097   Target *target = exe_ctx.GetTargetPtr();
1098   Process *process = exe_ctx.GetProcessPtr();
1099 
1100   if (target && process) {
1101     Process::StopLocker stop_locker;
1102     if (stop_locker.TryLock(&process->GetRunLock())) {
1103       frame = exe_ctx.GetFramePtr();
1104       if (frame) {
1105         std::unique_ptr<llvm::PrettyStackTraceFormat> stack_trace;
1106         if (target->GetDisplayExpressionsInCrashlogs()) {
1107           StreamString frame_description;
1108           frame->DumpUsingSettingsFormat(&frame_description);
1109           stack_trace = std::make_unique<llvm::PrettyStackTraceFormat>(
1110               "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
1111               "= %u) %s",
1112               expr, options.GetFetchDynamicValue(),
1113               frame_description.GetData());
1114         }
1115 
1116         target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
1117         expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
1118       }
1119     }
1120   }
1121 
1122   LLDB_LOGF(expr_log,
1123             "** [SBFrame::EvaluateExpression] Expression result is "
1124             "%s, summary %s **",
1125             expr_result.GetValue(), expr_result.GetSummary());
1126 
1127   return LLDB_RECORD_RESULT(expr_result);
1128 }
1129 
1130 bool SBFrame::IsInlined() {
1131   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
1132 
1133   return static_cast<const SBFrame *>(this)->IsInlined();
1134 }
1135 
1136 bool SBFrame::IsInlined() const {
1137   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
1138 
1139   std::unique_lock<std::recursive_mutex> lock;
1140   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1141 
1142   StackFrame *frame = nullptr;
1143   Target *target = exe_ctx.GetTargetPtr();
1144   Process *process = exe_ctx.GetProcessPtr();
1145   if (target && process) {
1146     Process::StopLocker stop_locker;
1147     if (stop_locker.TryLock(&process->GetRunLock())) {
1148       frame = exe_ctx.GetFramePtr();
1149       if (frame) {
1150 
1151         Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
1152         if (block)
1153           return block->GetContainingInlinedBlock() != nullptr;
1154       }
1155     }
1156   }
1157   return false;
1158 }
1159 
1160 bool SBFrame::IsArtificial() {
1161   LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
1162 
1163   return static_cast<const SBFrame *>(this)->IsArtificial();
1164 }
1165 
1166 bool SBFrame::IsArtificial() const {
1167   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
1168 
1169   std::unique_lock<std::recursive_mutex> lock;
1170   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1171 
1172   StackFrame *frame = exe_ctx.GetFramePtr();
1173   if (frame)
1174     return frame->IsArtificial();
1175 
1176   return false;
1177 }
1178 
1179 const char *SBFrame::GetFunctionName() {
1180   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
1181 
1182   return static_cast<const SBFrame *>(this)->GetFunctionName();
1183 }
1184 
1185 lldb::LanguageType SBFrame::GuessLanguage() const {
1186   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
1187 
1188   std::unique_lock<std::recursive_mutex> lock;
1189   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1190 
1191   StackFrame *frame = nullptr;
1192   Target *target = exe_ctx.GetTargetPtr();
1193   Process *process = exe_ctx.GetProcessPtr();
1194   if (target && process) {
1195     Process::StopLocker stop_locker;
1196     if (stop_locker.TryLock(&process->GetRunLock())) {
1197       frame = exe_ctx.GetFramePtr();
1198       if (frame) {
1199         return frame->GuessLanguage();
1200       }
1201     }
1202   }
1203   return eLanguageTypeUnknown;
1204 }
1205 
1206 const char *SBFrame::GetFunctionName() const {
1207   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
1208 
1209   const char *name = nullptr;
1210   std::unique_lock<std::recursive_mutex> lock;
1211   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1212 
1213   StackFrame *frame = nullptr;
1214   Target *target = exe_ctx.GetTargetPtr();
1215   Process *process = exe_ctx.GetProcessPtr();
1216   if (target && process) {
1217     Process::StopLocker stop_locker;
1218     if (stop_locker.TryLock(&process->GetRunLock())) {
1219       frame = exe_ctx.GetFramePtr();
1220       if (frame) {
1221         SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction |
1222                                                  eSymbolContextBlock |
1223                                                  eSymbolContextSymbol));
1224         if (sc.block) {
1225           Block *inlined_block = sc.block->GetContainingInlinedBlock();
1226           if (inlined_block) {
1227             const InlineFunctionInfo *inlined_info =
1228                 inlined_block->GetInlinedFunctionInfo();
1229             name = inlined_info->GetName().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().AsCString();
1273           }
1274         }
1275 
1276         if (name == nullptr) {
1277           if (sc.function)
1278             name = sc.function->GetDisplayName().GetCString();
1279         }
1280 
1281         if (name == nullptr) {
1282           if (sc.symbol)
1283             name = sc.symbol->GetDisplayName().GetCString();
1284         }
1285       }
1286     }
1287   }
1288   return name;
1289 }
1290 
1291 namespace lldb_private {
1292 namespace repro {
1293 
1294 template <>
1295 void RegisterMethods<SBFrame>(Registry &R) {
1296   LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
1297   LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
1298   LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
1299   LLDB_REGISTER_METHOD(const lldb::SBFrame &,
1300                        SBFrame, operator=,(const lldb::SBFrame &));
1301   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
1302   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
1303   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
1304                              (uint32_t));
1305   LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
1306   LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
1307                              ());
1308   LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
1309   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
1310   LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
1311   LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
1312   LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
1313   LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
1314   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
1315   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
1316   LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
1317   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
1318   LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
1319   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
1320   LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
1321   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
1322                        (const char *));
1323   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
1324                        (const char *, lldb::DynamicValueType));
1325   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
1326   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
1327                        (const char *, lldb::DynamicValueType));
1328   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
1329                        (const char *, lldb::ValueType));
1330   LLDB_REGISTER_METHOD(
1331       lldb::SBValue, SBFrame, FindValue,
1332       (const char *, lldb::ValueType, lldb::DynamicValueType));
1333   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
1334   LLDB_REGISTER_METHOD_CONST(bool,
1335                              SBFrame, operator==,(const lldb::SBFrame &));
1336   LLDB_REGISTER_METHOD_CONST(bool,
1337                              SBFrame, operator!=,(const lldb::SBFrame &));
1338   LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
1339   LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
1340   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1341                        (bool, bool, bool, bool));
1342   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1343                        (bool, bool, bool, bool, lldb::DynamicValueType));
1344   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1345                        (const lldb::SBVariablesOptions &));
1346   LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
1347   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
1348   LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
1349   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1350                        (const char *));
1351   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1352                        (const char *, lldb::DynamicValueType));
1353   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1354                        (const char *, lldb::DynamicValueType, bool));
1355   LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1356                        (const char *, const lldb::SBExpressionOptions &));
1357   LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
1358   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
1359   LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
1360   LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
1361   LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
1362   LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
1363   LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
1364   LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());
1365 }
1366 
1367 }
1368 }
1369