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
SBFrame()57 SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
58 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
59 }
60
SBFrame(const StackFrameSP & lldb_object_sp)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
SBFrame(const SBFrame & rhs)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
operator =(const SBFrame & rhs)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
GetFrameSP() const84 StackFrameSP SBFrame::GetFrameSP() const {
85 return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
86 }
87
SetFrameSP(const StackFrameSP & lldb_object_sp)88 void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
89 return m_opaque_sp->SetFrameSP(lldb_object_sp);
90 }
91
IsValid() const92 bool SBFrame::IsValid() const {
93 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
94 return this->operator bool();
95 }
operator bool() const96 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
GetSymbolContext(uint32_t resolve_scope) const114 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
GetModule() const137 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
GetCompileUnit() const162 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
GetFunction() const187 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
GetSymbol() const211 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
GetBlock() const234 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
GetFrameBlock() const255 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
GetLineEntry() const276 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
GetFrameID() const299 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
GetCFA() const314 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
GetPC() const326 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
SetPC(addr_t new_pc)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
GetSP() const373 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
GetFP() const396 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
GetPCAddress() const419 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
Clear()440 void SBFrame::Clear() {
441 LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
442
443 m_opaque_sp->Clear();
444 }
445
GetValueForVariablePath(const char * var_path)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
GetValueForVariablePath(const char * var_path,DynamicValueType use_dynamic)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
FindVariable(const char * name)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
FindVariable(const char * name,lldb::DynamicValueType use_dynamic)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
FindValue(const char * name,ValueType value_type)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
FindValue(const char * name,ValueType value_type,lldb::DynamicValueType use_dynamic)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
IsEqual(const SBFrame & that) const694 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
operator ==(const SBFrame & rhs) const703 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
operator !=(const SBFrame & rhs) const710 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
GetThread() const717 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
Disassemble() const729 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
GetVariables(bool arguments,bool locals,bool statics,bool in_scope_only)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
GetVariables(bool arguments,bool locals,bool statics,bool in_scope_only,lldb::DynamicValueType use_dynamic)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
GetVariables(const lldb::SBVariablesOptions & options)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
GetRegisters()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
FindRegister(const char * name)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
GetDescription(SBStream & description)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
EvaluateExpression(const char * expr)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
EvaluateExpression(const char * expr,lldb::DynamicValueType fetch_dynamic_value)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
EvaluateExpression(const char * expr,lldb::DynamicValueType fetch_dynamic_value,bool unwind_on_error)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
EvaluateExpression(const char * expr,const SBExpressionOptions & options)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
IsInlined()1130 bool SBFrame::IsInlined() {
1131 LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
1132
1133 return static_cast<const SBFrame *>(this)->IsInlined();
1134 }
1135
IsInlined() const1136 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
IsArtificial()1160 bool SBFrame::IsArtificial() {
1161 LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
1162
1163 return static_cast<const SBFrame *>(this)->IsArtificial();
1164 }
1165
IsArtificial() const1166 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
GetFunctionName()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
GuessLanguage() const1185 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
GetFunctionName() const1206 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
GetDisplayFunctionName()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 <>
RegisterMethods(Registry & R)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