1 //===-- SBFrame.cpp ---------------------------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
13 #include "lldb/API/SBFrame.h"
15 #include "lldb/lldb-types.h"
17 #include "SBReproducerPrivate.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"
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"
52 #include "llvm/Support/PrettyStackTrace.h"
55 using namespace lldb_private;
57 SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
58 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
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 &),
67 SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() {
68 LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
70 m_opaque_sp = clone(rhs.m_opaque_sp);
73 SBFrame::~SBFrame() = default;
75 const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
76 LLDB_RECORD_METHOD(const lldb::SBFrame &,
77 SBFrame, operator=,(const lldb::SBFrame &), rhs);
80 m_opaque_sp = clone(rhs.m_opaque_sp);
81 return LLDB_RECORD_RESULT(*this);
84 StackFrameSP SBFrame::GetFrameSP() const {
85 return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
88 void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
89 return m_opaque_sp->SetFrameSP(lldb_object_sp);
92 bool SBFrame::IsValid() const {
93 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
94 return this->operator bool();
96 SBFrame::operator bool() const {
97 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool);
99 std::unique_lock<std::recursive_mutex> lock;
100 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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;
110 // Without a target & process we can't have a valid stack frame.
114 SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
115 LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
116 (uint32_t), resolve_scope);
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();
130 sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext(scope));
134 return LLDB_RECORD_RESULT(sb_sym_ctx);
137 SBModule SBFrame::GetModule() const {
138 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
142 std::unique_lock<std::recursive_mutex> lock;
143 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
153 module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp;
154 sb_module.SetSP(module_sp);
159 return LLDB_RECORD_RESULT(sb_module);
162 SBCompileUnit SBFrame::GetCompileUnit() const {
163 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
166 SBCompileUnit sb_comp_unit;
167 std::unique_lock<std::recursive_mutex> lock;
168 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
179 frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit);
184 return LLDB_RECORD_RESULT(sb_comp_unit);
187 SBFunction SBFrame::GetFunction() const {
188 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
190 SBFunction sb_function;
191 std::unique_lock<std::recursive_mutex> lock;
192 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
203 frame->GetSymbolContext(eSymbolContextFunction).function);
208 return LLDB_RECORD_RESULT(sb_function);
211 SBSymbol SBFrame::GetSymbol() const {
212 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
215 std::unique_lock<std::recursive_mutex> lock;
216 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
226 sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol);
231 return LLDB_RECORD_RESULT(sb_symbol);
234 SBBlock SBFrame::GetBlock() const {
235 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
238 std::unique_lock<std::recursive_mutex> lock;
239 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
249 sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block);
252 return LLDB_RECORD_RESULT(sb_block);
255 SBBlock SBFrame::GetFrameBlock() const {
256 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
259 std::unique_lock<std::recursive_mutex> lock;
260 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
270 sb_block.SetPtr(frame->GetFrameBlock());
273 return LLDB_RECORD_RESULT(sb_block);
276 SBLineEntry SBFrame::GetLineEntry() const {
277 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
279 SBLineEntry sb_line_entry;
280 std::unique_lock<std::recursive_mutex> lock;
281 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
291 sb_line_entry.SetLineEntry(
292 frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
296 return LLDB_RECORD_RESULT(sb_line_entry);
299 uint32_t SBFrame::GetFrameID() const {
300 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
302 uint32_t frame_idx = UINT32_MAX;
304 std::unique_lock<std::recursive_mutex> lock;
305 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
307 StackFrame *frame = exe_ctx.GetFramePtr();
309 frame_idx = frame->GetFrameIndex();
314 lldb::addr_t SBFrame::GetCFA() const {
315 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
317 std::unique_lock<std::recursive_mutex> lock;
318 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
320 StackFrame *frame = exe_ctx.GetFramePtr();
322 return frame->GetStackID().GetCallFrameAddress();
323 return LLDB_INVALID_ADDRESS;
326 addr_t SBFrame::GetPC() const {
327 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
329 addr_t addr = LLDB_INVALID_ADDRESS;
330 std::unique_lock<std::recursive_mutex> lock;
331 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
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();
341 addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
342 target, AddressClass::eCode);
350 bool SBFrame::SetPC(addr_t new_pc) {
351 LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
353 bool ret_val = false;
354 std::unique_lock<std::recursive_mutex> lock;
355 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
357 StackFrame *frame = nullptr;
358 Target *target = exe_ctx.GetTargetPtr();
359 Process *process = exe_ctx.GetProcessPtr();
360 if (target && process) {
361 Process::StopLocker stop_locker;
362 if (stop_locker.TryLock(&process->GetRunLock())) {
363 frame = exe_ctx.GetFramePtr();
365 ret_val = frame->GetRegisterContext()->SetPC(new_pc);
373 addr_t SBFrame::GetSP() const {
374 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
376 addr_t addr = LLDB_INVALID_ADDRESS;
377 std::unique_lock<std::recursive_mutex> lock;
378 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
380 StackFrame *frame = nullptr;
381 Target *target = exe_ctx.GetTargetPtr();
382 Process *process = exe_ctx.GetProcessPtr();
383 if (target && process) {
384 Process::StopLocker stop_locker;
385 if (stop_locker.TryLock(&process->GetRunLock())) {
386 frame = exe_ctx.GetFramePtr();
388 addr = frame->GetRegisterContext()->GetSP();
396 addr_t SBFrame::GetFP() const {
397 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
399 addr_t addr = LLDB_INVALID_ADDRESS;
400 std::unique_lock<std::recursive_mutex> lock;
401 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
403 StackFrame *frame = nullptr;
404 Target *target = exe_ctx.GetTargetPtr();
405 Process *process = exe_ctx.GetProcessPtr();
406 if (target && process) {
407 Process::StopLocker stop_locker;
408 if (stop_locker.TryLock(&process->GetRunLock())) {
409 frame = exe_ctx.GetFramePtr();
411 addr = frame->GetRegisterContext()->GetFP();
418 SBAddress SBFrame::GetPCAddress() const {
419 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
422 std::unique_lock<std::recursive_mutex> lock;
423 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
425 StackFrame *frame = exe_ctx.GetFramePtr();
426 Target *target = exe_ctx.GetTargetPtr();
427 Process *process = exe_ctx.GetProcessPtr();
428 if (target && process) {
429 Process::StopLocker stop_locker;
430 if (stop_locker.TryLock(&process->GetRunLock())) {
431 frame = exe_ctx.GetFramePtr();
433 sb_addr.SetAddress(&frame->GetFrameCodeAddress());
436 return LLDB_RECORD_RESULT(sb_addr);
439 void SBFrame::Clear() {
440 LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
442 m_opaque_sp->Clear();
445 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
446 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
447 (const char *), var_path);
450 std::unique_lock<std::recursive_mutex> lock;
451 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
453 StackFrame *frame = exe_ctx.GetFramePtr();
454 Target *target = exe_ctx.GetTargetPtr();
455 if (frame && target) {
456 lldb::DynamicValueType use_dynamic =
457 frame->CalculateTarget()->GetPreferDynamicValue();
458 sb_value = GetValueForVariablePath(var_path, use_dynamic);
460 return LLDB_RECORD_RESULT(sb_value);
463 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
464 DynamicValueType use_dynamic) {
465 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
466 (const char *, lldb::DynamicValueType), var_path,
470 if (var_path == nullptr || var_path[0] == '\0') {
471 return LLDB_RECORD_RESULT(sb_value);
474 std::unique_lock<std::recursive_mutex> lock;
475 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
477 StackFrame *frame = nullptr;
478 Target *target = exe_ctx.GetTargetPtr();
479 Process *process = exe_ctx.GetProcessPtr();
480 if (target && process) {
481 Process::StopLocker stop_locker;
482 if (stop_locker.TryLock(&process->GetRunLock())) {
483 frame = exe_ctx.GetFramePtr();
487 ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
488 var_path, eNoDynamicValues,
489 StackFrame::eExpressionPathOptionCheckPtrVsMember |
490 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
492 sb_value.SetSP(value_sp, use_dynamic);
496 return LLDB_RECORD_RESULT(sb_value);
499 SBValue SBFrame::FindVariable(const char *name) {
500 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
504 std::unique_lock<std::recursive_mutex> lock;
505 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
507 StackFrame *frame = exe_ctx.GetFramePtr();
508 Target *target = exe_ctx.GetTargetPtr();
509 if (frame && target) {
510 lldb::DynamicValueType use_dynamic =
511 frame->CalculateTarget()->GetPreferDynamicValue();
512 value = FindVariable(name, use_dynamic);
514 return LLDB_RECORD_RESULT(value);
517 SBValue SBFrame::FindVariable(const char *name,
518 lldb::DynamicValueType use_dynamic) {
519 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
520 (const char *, lldb::DynamicValueType), name, use_dynamic);
525 if (name == nullptr || name[0] == '\0') {
526 return LLDB_RECORD_RESULT(sb_value);
529 ValueObjectSP value_sp;
530 std::unique_lock<std::recursive_mutex> lock;
531 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
533 StackFrame *frame = nullptr;
534 Target *target = exe_ctx.GetTargetPtr();
535 Process *process = exe_ctx.GetProcessPtr();
536 if (target && process) {
537 Process::StopLocker stop_locker;
538 if (stop_locker.TryLock(&process->GetRunLock())) {
539 frame = exe_ctx.GetFramePtr();
541 value_sp = frame->FindVariable(ConstString(name));
544 sb_value.SetSP(value_sp, use_dynamic);
549 return LLDB_RECORD_RESULT(sb_value);
552 SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
553 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
554 (const char *, lldb::ValueType), name, value_type);
557 std::unique_lock<std::recursive_mutex> lock;
558 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
560 StackFrame *frame = exe_ctx.GetFramePtr();
561 Target *target = exe_ctx.GetTargetPtr();
562 if (frame && target) {
563 lldb::DynamicValueType use_dynamic =
564 frame->CalculateTarget()->GetPreferDynamicValue();
565 value = FindValue(name, value_type, use_dynamic);
567 return LLDB_RECORD_RESULT(value);
570 SBValue SBFrame::FindValue(const char *name, ValueType value_type,
571 lldb::DynamicValueType use_dynamic) {
572 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
573 (const char *, lldb::ValueType, lldb::DynamicValueType),
574 name, value_type, use_dynamic);
578 if (name == nullptr || name[0] == '\0') {
579 return LLDB_RECORD_RESULT(sb_value);
582 ValueObjectSP value_sp;
583 std::unique_lock<std::recursive_mutex> lock;
584 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
586 StackFrame *frame = nullptr;
587 Target *target = exe_ctx.GetTargetPtr();
588 Process *process = exe_ctx.GetProcessPtr();
589 if (target && process) {
590 Process::StopLocker stop_locker;
591 if (stop_locker.TryLock(&process->GetRunLock())) {
592 frame = exe_ctx.GetFramePtr();
594 VariableList variable_list;
596 switch (value_type) {
597 case eValueTypeVariableGlobal: // global variable
598 case eValueTypeVariableStatic: // static variable
599 case eValueTypeVariableArgument: // function argument variables
600 case eValueTypeVariableLocal: // function local variables
601 case eValueTypeVariableThreadLocal: // thread local variables
603 SymbolContext sc(frame->GetSymbolContext(eSymbolContextBlock));
605 const bool can_create = true;
606 const bool get_parent_variables = true;
607 const bool stop_if_block_is_inlined_function = true;
610 sc.block->AppendVariables(
611 can_create, get_parent_variables,
612 stop_if_block_is_inlined_function,
613 [frame](Variable *v) { return v->IsInScope(frame); },
615 if (value_type == eValueTypeVariableGlobal) {
616 const bool get_file_globals = true;
617 VariableList *frame_vars = frame->GetVariableList(get_file_globals);
619 frame_vars->AppendVariablesIfUnique(variable_list);
621 ConstString const_name(name);
622 VariableSP variable_sp(
623 variable_list.FindVariable(const_name, value_type));
625 value_sp = frame->GetValueObjectForFrameVariable(variable_sp,
627 sb_value.SetSP(value_sp, use_dynamic);
631 case eValueTypeRegister: // stack frame register value
633 RegisterContextSP reg_ctx(frame->GetRegisterContext());
635 const uint32_t num_regs = reg_ctx->GetRegisterCount();
636 for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
637 const RegisterInfo *reg_info =
638 reg_ctx->GetRegisterInfoAtIndex(reg_idx);
640 ((reg_info->name && strcasecmp(reg_info->name, name) == 0) ||
641 (reg_info->alt_name &&
642 strcasecmp(reg_info->alt_name, name) == 0))) {
643 value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
644 sb_value.SetSP(value_sp);
651 case eValueTypeRegisterSet: // A collection of stack frame register
654 RegisterContextSP reg_ctx(frame->GetRegisterContext());
656 const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
657 for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
658 const RegisterSet *reg_set = reg_ctx->GetRegisterSet(set_idx);
660 ((reg_set->name && strcasecmp(reg_set->name, name) == 0) ||
661 (reg_set->short_name &&
662 strcasecmp(reg_set->short_name, name) == 0))) {
664 ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx);
665 sb_value.SetSP(value_sp);
672 case eValueTypeConstResult: // constant result variables
674 ConstString const_name(name);
675 ExpressionVariableSP expr_var_sp(
676 target->GetPersistentVariable(const_name));
678 value_sp = expr_var_sp->GetValueObject();
679 sb_value.SetSP(value_sp, use_dynamic);
690 return LLDB_RECORD_RESULT(sb_value);
693 bool SBFrame::IsEqual(const SBFrame &that) const {
694 LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
697 lldb::StackFrameSP this_sp = GetFrameSP();
698 lldb::StackFrameSP that_sp = that.GetFrameSP();
699 return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
702 bool SBFrame::operator==(const SBFrame &rhs) const {
703 LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
709 bool SBFrame::operator!=(const SBFrame &rhs) const {
710 LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
713 return !IsEqual(rhs);
716 SBThread SBFrame::GetThread() const {
717 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
719 std::unique_lock<std::recursive_mutex> lock;
720 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
722 ThreadSP thread_sp(exe_ctx.GetThreadSP());
723 SBThread sb_thread(thread_sp);
725 return LLDB_RECORD_RESULT(sb_thread);
728 const char *SBFrame::Disassemble() const {
729 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
731 const char *disassembly = nullptr;
732 std::unique_lock<std::recursive_mutex> lock;
733 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
735 StackFrame *frame = nullptr;
736 Target *target = exe_ctx.GetTargetPtr();
737 Process *process = exe_ctx.GetProcessPtr();
738 if (target && process) {
739 Process::StopLocker stop_locker;
740 if (stop_locker.TryLock(&process->GetRunLock())) {
741 frame = exe_ctx.GetFramePtr();
743 disassembly = frame->Disassemble();
751 SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
752 bool in_scope_only) {
753 LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
754 (bool, bool, bool, bool), arguments, locals, statics,
757 SBValueList value_list;
758 std::unique_lock<std::recursive_mutex> lock;
759 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
761 StackFrame *frame = exe_ctx.GetFramePtr();
762 Target *target = exe_ctx.GetTargetPtr();
763 if (frame && target) {
764 lldb::DynamicValueType use_dynamic =
765 frame->CalculateTarget()->GetPreferDynamicValue();
766 const bool include_runtime_support_values =
767 target ? target->GetDisplayRuntimeSupportValues() : false;
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);
777 value_list = GetVariables(options);
779 return LLDB_RECORD_RESULT(value_list);
782 lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
783 bool statics, bool in_scope_only,
784 lldb::DynamicValueType use_dynamic) {
785 LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
786 (bool, bool, bool, bool, lldb::DynamicValueType),
787 arguments, locals, statics, in_scope_only, use_dynamic);
789 std::unique_lock<std::recursive_mutex> lock;
790 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
792 Target *target = exe_ctx.GetTargetPtr();
793 const bool include_runtime_support_values =
794 target ? target->GetDisplayRuntimeSupportValues() : false;
795 SBVariablesOptions options;
796 options.SetIncludeArguments(arguments);
797 options.SetIncludeLocals(locals);
798 options.SetIncludeStatics(statics);
799 options.SetInScopeOnly(in_scope_only);
800 options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
801 options.SetUseDynamic(use_dynamic);
802 return LLDB_RECORD_RESULT(GetVariables(options));
805 SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
806 LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
807 (const lldb::SBVariablesOptions &), options);
809 SBValueList value_list;
810 std::unique_lock<std::recursive_mutex> lock;
811 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
813 StackFrame *frame = nullptr;
814 Target *target = exe_ctx.GetTargetPtr();
816 const bool statics = options.GetIncludeStatics();
817 const bool arguments = options.GetIncludeArguments();
818 const bool recognized_arguments =
819 options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP()));
820 const bool locals = options.GetIncludeLocals();
821 const bool in_scope_only = options.GetInScopeOnly();
822 const bool include_runtime_support_values =
823 options.GetIncludeRuntimeSupportValues();
824 const lldb::DynamicValueType use_dynamic = options.GetUseDynamic();
827 std::set<VariableSP> variable_set;
828 Process *process = exe_ctx.GetProcessPtr();
829 if (target && process) {
830 Process::StopLocker stop_locker;
831 if (stop_locker.TryLock(&process->GetRunLock())) {
832 frame = exe_ctx.GetFramePtr();
835 VariableList *variable_list = nullptr;
836 variable_list = frame->GetVariableList(true);
838 const size_t num_variables = variable_list->GetSize();
840 for (i = 0; i < num_variables; ++i) {
841 VariableSP variable_sp(variable_list->GetVariableAtIndex(i));
843 bool add_variable = false;
844 switch (variable_sp->GetScope()) {
845 case eValueTypeVariableGlobal:
846 case eValueTypeVariableStatic:
847 case eValueTypeVariableThreadLocal:
848 add_variable = statics;
851 case eValueTypeVariableArgument:
852 add_variable = arguments;
855 case eValueTypeVariableLocal:
856 add_variable = locals;
863 // Only add variables once so we don't end up with duplicates
864 if (variable_set.find(variable_sp) == variable_set.end())
865 variable_set.insert(variable_sp);
869 if (in_scope_only && !variable_sp->IsInScope(frame))
872 ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable(
873 variable_sp, eNoDynamicValues));
875 if (!include_runtime_support_values && valobj_sp != nullptr &&
876 valobj_sp->IsRuntimeSupportValue())
880 value_sb.SetSP(valobj_sp, use_dynamic);
881 value_list.Append(value_sb);
887 if (recognized_arguments) {
888 auto recognized_frame = frame->GetRecognizedFrame();
889 if (recognized_frame) {
890 ValueObjectListSP recognized_arg_list =
891 recognized_frame->GetRecognizedArguments();
892 if (recognized_arg_list) {
893 for (auto &rec_value_sp : recognized_arg_list->GetObjects()) {
895 value_sb.SetSP(rec_value_sp, use_dynamic);
896 value_list.Append(value_sb);
905 return LLDB_RECORD_RESULT(value_list);
908 SBValueList SBFrame::GetRegisters() {
909 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
911 SBValueList value_list;
912 std::unique_lock<std::recursive_mutex> lock;
913 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
915 StackFrame *frame = nullptr;
916 Target *target = exe_ctx.GetTargetPtr();
917 Process *process = exe_ctx.GetProcessPtr();
918 if (target && process) {
919 Process::StopLocker stop_locker;
920 if (stop_locker.TryLock(&process->GetRunLock())) {
921 frame = exe_ctx.GetFramePtr();
923 RegisterContextSP reg_ctx(frame->GetRegisterContext());
925 const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
926 for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
928 ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx));
935 return LLDB_RECORD_RESULT(value_list);
938 SBValue SBFrame::FindRegister(const char *name) {
939 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
943 ValueObjectSP value_sp;
944 std::unique_lock<std::recursive_mutex> lock;
945 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
947 StackFrame *frame = nullptr;
948 Target *target = exe_ctx.GetTargetPtr();
949 Process *process = exe_ctx.GetProcessPtr();
950 if (target && process) {
951 Process::StopLocker stop_locker;
952 if (stop_locker.TryLock(&process->GetRunLock())) {
953 frame = exe_ctx.GetFramePtr();
955 RegisterContextSP reg_ctx(frame->GetRegisterContext());
957 const uint32_t num_regs = reg_ctx->GetRegisterCount();
958 for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
959 const RegisterInfo *reg_info =
960 reg_ctx->GetRegisterInfoAtIndex(reg_idx);
962 ((reg_info->name && strcasecmp(reg_info->name, name) == 0) ||
963 (reg_info->alt_name &&
964 strcasecmp(reg_info->alt_name, name) == 0))) {
965 value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
966 result.SetSP(value_sp);
975 return LLDB_RECORD_RESULT(result);
978 bool SBFrame::GetDescription(SBStream &description) {
979 LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
982 Stream &strm = description.ref();
984 std::unique_lock<std::recursive_mutex> lock;
985 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
988 Target *target = exe_ctx.GetTargetPtr();
989 Process *process = exe_ctx.GetProcessPtr();
990 if (target && process) {
991 Process::StopLocker stop_locker;
992 if (stop_locker.TryLock(&process->GetRunLock())) {
993 frame = exe_ctx.GetFramePtr();
995 frame->DumpUsingSettingsFormat(&strm);
1000 strm.PutCString("No value");
1005 SBValue SBFrame::EvaluateExpression(const char *expr) {
1006 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
1010 std::unique_lock<std::recursive_mutex> lock;
1011 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1013 StackFrame *frame = exe_ctx.GetFramePtr();
1014 Target *target = exe_ctx.GetTargetPtr();
1015 if (frame && target) {
1016 SBExpressionOptions options;
1017 lldb::DynamicValueType fetch_dynamic_value =
1018 frame->CalculateTarget()->GetPreferDynamicValue();
1019 options.SetFetchDynamicValue(fetch_dynamic_value);
1020 options.SetUnwindOnError(true);
1021 options.SetIgnoreBreakpoints(true);
1022 if (target->GetLanguage() != eLanguageTypeUnknown)
1023 options.SetLanguage(target->GetLanguage());
1025 options.SetLanguage(frame->GetLanguage());
1026 return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
1028 return LLDB_RECORD_RESULT(result);
1032 SBFrame::EvaluateExpression(const char *expr,
1033 lldb::DynamicValueType fetch_dynamic_value) {
1034 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1035 (const char *, lldb::DynamicValueType), expr,
1036 fetch_dynamic_value);
1038 SBExpressionOptions options;
1039 options.SetFetchDynamicValue(fetch_dynamic_value);
1040 options.SetUnwindOnError(true);
1041 options.SetIgnoreBreakpoints(true);
1042 std::unique_lock<std::recursive_mutex> lock;
1043 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1045 StackFrame *frame = exe_ctx.GetFramePtr();
1046 Target *target = exe_ctx.GetTargetPtr();
1047 if (target && target->GetLanguage() != eLanguageTypeUnknown)
1048 options.SetLanguage(target->GetLanguage());
1050 options.SetLanguage(frame->GetLanguage());
1051 return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
1054 SBValue SBFrame::EvaluateExpression(const char *expr,
1055 lldb::DynamicValueType fetch_dynamic_value,
1056 bool unwind_on_error) {
1057 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1058 (const char *, lldb::DynamicValueType, bool), expr,
1059 fetch_dynamic_value, unwind_on_error);
1061 SBExpressionOptions options;
1062 std::unique_lock<std::recursive_mutex> lock;
1063 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1065 options.SetFetchDynamicValue(fetch_dynamic_value);
1066 options.SetUnwindOnError(unwind_on_error);
1067 options.SetIgnoreBreakpoints(true);
1068 StackFrame *frame = exe_ctx.GetFramePtr();
1069 Target *target = exe_ctx.GetTargetPtr();
1070 if (target && target->GetLanguage() != eLanguageTypeUnknown)
1071 options.SetLanguage(target->GetLanguage());
1073 options.SetLanguage(frame->GetLanguage());
1074 return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
1077 lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
1078 const SBExpressionOptions &options) {
1079 LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1080 (const char *, const lldb::SBExpressionOptions &), expr,
1083 Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1085 SBValue expr_result;
1087 if (expr == nullptr || expr[0] == '\0') {
1088 return LLDB_RECORD_RESULT(expr_result);
1091 ValueObjectSP expr_value_sp;
1093 std::unique_lock<std::recursive_mutex> lock;
1094 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1097 StackFrame *frame = nullptr;
1098 Target *target = exe_ctx.GetTargetPtr();
1099 Process *process = exe_ctx.GetProcessPtr();
1101 if (target && process) {
1102 Process::StopLocker stop_locker;
1103 if (stop_locker.TryLock(&process->GetRunLock())) {
1104 frame = exe_ctx.GetFramePtr();
1106 std::unique_ptr<llvm::PrettyStackTraceFormat> stack_trace;
1107 if (target->GetDisplayExpressionsInCrashlogs()) {
1108 StreamString frame_description;
1109 frame->DumpUsingSettingsFormat(&frame_description);
1110 stack_trace = llvm::make_unique<llvm::PrettyStackTraceFormat>(
1111 "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
1113 expr, options.GetFetchDynamicValue(),
1114 frame_description.GetData());
1117 target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
1118 expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
1124 expr_log->Printf("** [SBFrame::EvaluateExpression] Expression result is "
1125 "%s, summary %s **",
1126 expr_result.GetValue(), expr_result.GetSummary());
1128 return LLDB_RECORD_RESULT(expr_result);
1131 bool SBFrame::IsInlined() {
1132 LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
1134 return static_cast<const SBFrame *>(this)->IsInlined();
1137 bool SBFrame::IsInlined() const {
1138 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
1140 std::unique_lock<std::recursive_mutex> lock;
1141 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1143 StackFrame *frame = nullptr;
1144 Target *target = exe_ctx.GetTargetPtr();
1145 Process *process = exe_ctx.GetProcessPtr();
1146 if (target && process) {
1147 Process::StopLocker stop_locker;
1148 if (stop_locker.TryLock(&process->GetRunLock())) {
1149 frame = exe_ctx.GetFramePtr();
1152 Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
1154 return block->GetContainingInlinedBlock() != nullptr;
1161 bool SBFrame::IsArtificial() {
1162 LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
1164 return static_cast<const SBFrame *>(this)->IsArtificial();
1167 bool SBFrame::IsArtificial() const {
1168 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
1170 std::unique_lock<std::recursive_mutex> lock;
1171 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1173 StackFrame *frame = exe_ctx.GetFramePtr();
1175 return frame->IsArtificial();
1180 const char *SBFrame::GetFunctionName() {
1181 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
1183 return static_cast<const SBFrame *>(this)->GetFunctionName();
1186 lldb::LanguageType SBFrame::GuessLanguage() const {
1187 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
1189 std::unique_lock<std::recursive_mutex> lock;
1190 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1192 StackFrame *frame = nullptr;
1193 Target *target = exe_ctx.GetTargetPtr();
1194 Process *process = exe_ctx.GetProcessPtr();
1195 if (target && process) {
1196 Process::StopLocker stop_locker;
1197 if (stop_locker.TryLock(&process->GetRunLock())) {
1198 frame = exe_ctx.GetFramePtr();
1200 return frame->GuessLanguage();
1204 return eLanguageTypeUnknown;
1207 const char *SBFrame::GetFunctionName() const {
1208 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
1210 const char *name = nullptr;
1211 std::unique_lock<std::recursive_mutex> lock;
1212 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1214 StackFrame *frame = nullptr;
1215 Target *target = exe_ctx.GetTargetPtr();
1216 Process *process = exe_ctx.GetProcessPtr();
1217 if (target && process) {
1218 Process::StopLocker stop_locker;
1219 if (stop_locker.TryLock(&process->GetRunLock())) {
1220 frame = exe_ctx.GetFramePtr();
1222 SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction |
1223 eSymbolContextBlock |
1224 eSymbolContextSymbol));
1226 Block *inlined_block = sc.block->GetContainingInlinedBlock();
1227 if (inlined_block) {
1228 const InlineFunctionInfo *inlined_info =
1229 inlined_block->GetInlinedFunctionInfo();
1231 inlined_info->GetName(sc.function->GetLanguage()).AsCString();
1235 if (name == nullptr) {
1237 name = sc.function->GetName().GetCString();
1240 if (name == nullptr) {
1242 name = sc.symbol->GetName().GetCString();
1250 const char *SBFrame::GetDisplayFunctionName() {
1251 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
1253 const char *name = nullptr;
1255 std::unique_lock<std::recursive_mutex> lock;
1256 ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
1258 StackFrame *frame = nullptr;
1259 Target *target = exe_ctx.GetTargetPtr();
1260 Process *process = exe_ctx.GetProcessPtr();
1261 if (target && process) {
1262 Process::StopLocker stop_locker;
1263 if (stop_locker.TryLock(&process->GetRunLock())) {
1264 frame = exe_ctx.GetFramePtr();
1266 SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction |
1267 eSymbolContextBlock |
1268 eSymbolContextSymbol));
1270 Block *inlined_block = sc.block->GetContainingInlinedBlock();
1271 if (inlined_block) {
1272 const InlineFunctionInfo *inlined_info =
1273 inlined_block->GetInlinedFunctionInfo();
1274 name = inlined_info->GetDisplayName(sc.function->GetLanguage())
1279 if (name == nullptr) {
1281 name = sc.function->GetDisplayName().GetCString();
1284 if (name == nullptr) {
1286 name = sc.symbol->GetDisplayName().GetCString();
1294 namespace lldb_private {
1298 void RegisterMethods<SBFrame>(Registry &R) {
1299 LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
1300 LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
1301 LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
1302 LLDB_REGISTER_METHOD(const lldb::SBFrame &,
1303 SBFrame, operator=,(const lldb::SBFrame &));
1304 LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
1305 LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
1306 LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
1308 LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
1309 LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
1311 LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
1312 LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
1313 LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
1314 LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetFrameBlock, ());
1315 LLDB_REGISTER_METHOD_CONST(lldb::SBLineEntry, SBFrame, GetLineEntry, ());
1316 LLDB_REGISTER_METHOD_CONST(uint32_t, SBFrame, GetFrameID, ());
1317 LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetCFA, ());
1318 LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetPC, ());
1319 LLDB_REGISTER_METHOD(bool, SBFrame, SetPC, (lldb::addr_t));
1320 LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetSP, ());
1321 LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBFrame, GetFP, ());
1322 LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBFrame, GetPCAddress, ());
1323 LLDB_REGISTER_METHOD(void, SBFrame, Clear, ());
1324 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
1326 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
1327 (const char *, lldb::DynamicValueType));
1328 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *));
1329 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindVariable,
1330 (const char *, lldb::DynamicValueType));
1331 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindValue,
1332 (const char *, lldb::ValueType));
1333 LLDB_REGISTER_METHOD(
1334 lldb::SBValue, SBFrame, FindValue,
1335 (const char *, lldb::ValueType, lldb::DynamicValueType));
1336 LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &));
1337 LLDB_REGISTER_METHOD_CONST(bool,
1338 SBFrame, operator==,(const lldb::SBFrame &));
1339 LLDB_REGISTER_METHOD_CONST(bool,
1340 SBFrame, operator!=,(const lldb::SBFrame &));
1341 LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBFrame, GetThread, ());
1342 LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, Disassemble, ());
1343 LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1344 (bool, bool, bool, bool));
1345 LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1346 (bool, bool, bool, bool, lldb::DynamicValueType));
1347 LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetVariables,
1348 (const lldb::SBVariablesOptions &));
1349 LLDB_REGISTER_METHOD(lldb::SBValueList, SBFrame, GetRegisters, ());
1350 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *));
1351 LLDB_REGISTER_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &));
1352 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1354 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1355 (const char *, lldb::DynamicValueType));
1356 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1357 (const char *, lldb::DynamicValueType, bool));
1358 LLDB_REGISTER_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
1359 (const char *, const lldb::SBExpressionOptions &));
1360 LLDB_REGISTER_METHOD(bool, SBFrame, IsInlined, ());
1361 LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsInlined, ());
1362 LLDB_REGISTER_METHOD(bool, SBFrame, IsArtificial, ());
1363 LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsArtificial, ());
1364 LLDB_REGISTER_METHOD(const char *, SBFrame, GetFunctionName, ());
1365 LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBFrame, GuessLanguage, ());
1366 LLDB_REGISTER_METHOD_CONST(const char *, SBFrame, GetFunctionName, ());
1367 LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());