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