1//===-- StackFrame.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 "lldb/Target/StackFrame.h"
10#include "lldb/Core/Debugger.h"
11#include "lldb/Core/Disassembler.h"
12#include "lldb/Core/FormatEntity.h"
13#include "lldb/Core/Mangled.h"
14#include "lldb/Core/Module.h"
15#include "lldb/Core/Value.h"
16#include "lldb/Symbol/CompileUnit.h"
17#include "lldb/Symbol/Function.h"
18#include "lldb/Symbol/Symbol.h"
19#include "lldb/Symbol/SymbolContextScope.h"
20#include "lldb/Symbol/SymbolFile.h"
21#include "lldb/Symbol/Type.h"
22#include "lldb/Symbol/VariableList.h"
23#include "lldb/Target/ABI.h"
24#include "lldb/Target/ExecutionContext.h"
25#include "lldb/Target/LanguageRuntime.h"
26#include "lldb/Target/Process.h"
27#include "lldb/Target/RegisterContext.h"
28#include "lldb/Target/StackFrameRecognizer.h"
29#include "lldb/Target/Target.h"
30#include "lldb/Target/Thread.h"
31#include "lldb/Utility/LLDBLog.h"
32#include "lldb/Utility/Log.h"
33#include "lldb/Utility/RegisterValue.h"
34#include "lldb/ValueObject/DILEval.h"
35#include "lldb/ValueObject/DILLexer.h"
36#include "lldb/ValueObject/DILParser.h"
37#include "lldb/ValueObject/ValueObjectConstResult.h"
38#include "lldb/ValueObject/ValueObjectMemory.h"
39#include "lldb/ValueObject/ValueObjectVariable.h"
40
41#include "lldb/lldb-enumerations.h"
42
43#include <memory>
44
45using namespace lldb;
46using namespace lldb_private;
47
48// The first bits in the flags are reserved for the SymbolContext::Scope bits
49// so we know if we have tried to look up information in our internal symbol
50// context (m_sc) already.
51#define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextLastItem) << 1)
52#define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
53#define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
54#define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1)
55#define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1)
56
57StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
58 user_id_t unwind_frame_index, addr_t cfa,
59 bool cfa_is_valid, addr_t pc, StackFrame::Kind kind,
60 bool behaves_like_zeroth_frame,
61 const SymbolContext *sc_ptr)
62 : m_thread_wp(thread_sp), m_frame_index(frame_idx),
63 m_concrete_frame_index(unwind_frame_index), m_reg_context_sp(),
64 m_id(pc, cfa, nullptr), m_frame_code_addr(pc), m_sc(), m_flags(),
65 m_frame_base(), m_frame_base_error(), m_cfa_is_valid(cfa_is_valid),
66 m_stack_frame_kind(kind),
67 m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
68 m_variable_list_sp(), m_variable_list_value_objects(),
69 m_recognized_frame_sp(), m_disassembly(), m_mutex() {
70 // If we don't have a CFA value, use the frame index for our StackID so that
71 // recursive functions properly aren't confused with one another on a history
72 // stack.
73 if (IsHistorical() && !m_cfa_is_valid) {
74 m_id.SetCFA(m_frame_index);
75 }
76
77 if (sc_ptr != nullptr) {
78 m_sc = *sc_ptr;
79 m_flags.Set(m_sc.GetResolvedMask());
80 }
81}
82
83StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
84 user_id_t unwind_frame_index,
85 const RegisterContextSP &reg_context_sp, addr_t cfa,
86 addr_t pc, bool behaves_like_zeroth_frame,
87 const SymbolContext *sc_ptr)
88 : m_thread_wp(thread_sp), m_frame_index(frame_idx),
89 m_concrete_frame_index(unwind_frame_index),
90 m_reg_context_sp(reg_context_sp), m_id(pc, cfa, nullptr),
91 m_frame_code_addr(pc), m_sc(), m_flags(), m_frame_base(),
92 m_frame_base_error(), m_cfa_is_valid(true),
93 m_stack_frame_kind(StackFrame::Kind::Regular),
94 m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
95 m_variable_list_sp(), m_variable_list_value_objects(),
96 m_recognized_frame_sp(), m_disassembly(), m_mutex() {
97 if (sc_ptr != nullptr) {
98 m_sc = *sc_ptr;
99 m_flags.Set(m_sc.GetResolvedMask());
100 }
101
102 if (reg_context_sp && !m_sc.target_sp) {
103 m_sc.target_sp = reg_context_sp->CalculateTarget();
104 if (m_sc.target_sp)
105 m_flags.Set(eSymbolContextTarget);
106 }
107}
108
109StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
110 user_id_t unwind_frame_index,
111 const RegisterContextSP &reg_context_sp, addr_t cfa,
112 const Address &pc_addr, bool behaves_like_zeroth_frame,
113 const SymbolContext *sc_ptr)
114 : m_thread_wp(thread_sp), m_frame_index(frame_idx),
115 m_concrete_frame_index(unwind_frame_index),
116 m_reg_context_sp(reg_context_sp),
117 m_id(pc_addr.GetLoadAddress(target: thread_sp->CalculateTarget().get()), cfa,
118 nullptr),
119 m_frame_code_addr(pc_addr), m_sc(), m_flags(), m_frame_base(),
120 m_frame_base_error(), m_cfa_is_valid(true),
121 m_stack_frame_kind(StackFrame::Kind::Regular),
122 m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
123 m_variable_list_sp(), m_variable_list_value_objects(),
124 m_recognized_frame_sp(), m_disassembly(), m_mutex() {
125 if (sc_ptr != nullptr) {
126 m_sc = *sc_ptr;
127 m_flags.Set(m_sc.GetResolvedMask());
128 }
129
130 if (!m_sc.target_sp && reg_context_sp) {
131 m_sc.target_sp = reg_context_sp->CalculateTarget();
132 if (m_sc.target_sp)
133 m_flags.Set(eSymbolContextTarget);
134 }
135
136 ModuleSP pc_module_sp(pc_addr.GetModule());
137 if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp) {
138 if (pc_module_sp) {
139 m_sc.module_sp = pc_module_sp;
140 m_flags.Set(eSymbolContextModule);
141 } else {
142 m_sc.module_sp.reset();
143 }
144 }
145}
146
147StackFrame::~StackFrame() = default;
148
149StackID &StackFrame::GetStackID() {
150 std::lock_guard<std::recursive_mutex> guard(m_mutex);
151 // Make sure we have resolved the StackID object's symbol context scope if we
152 // already haven't looked it up.
153
154 if (m_flags.IsClear(RESOLVED_FRAME_ID_SYMBOL_SCOPE)) {
155 if (m_id.GetSymbolContextScope()) {
156 // We already have a symbol context scope, we just don't have our flag
157 // bit set.
158 m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
159 } else {
160 // Calculate the frame block and use this for the stack ID symbol context
161 // scope if we have one.
162 SymbolContextScope *scope = GetFrameBlock();
163 if (scope == nullptr) {
164 // We don't have a block, so use the symbol
165 if (m_flags.IsClear(bit: eSymbolContextSymbol))
166 GetSymbolContext(resolve_scope: eSymbolContextSymbol);
167
168 // It is ok if m_sc.symbol is nullptr here
169 scope = m_sc.symbol;
170 }
171 // Set the symbol context scope (the accessor will set the
172 // RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags).
173 SetSymbolContextScope(scope);
174 }
175 }
176 return m_id;
177}
178
179uint32_t StackFrame::GetFrameIndex() const {
180 ThreadSP thread_sp = GetThread();
181 if (thread_sp)
182 return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
183 idx: m_frame_index);
184 else
185 return m_frame_index;
186}
187
188void StackFrame::SetSymbolContextScope(SymbolContextScope *symbol_scope) {
189 std::lock_guard<std::recursive_mutex> guard(m_mutex);
190 m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
191 m_id.SetSymbolContextScope(symbol_scope);
192}
193
194const Address &StackFrame::GetFrameCodeAddress() {
195 std::lock_guard<std::recursive_mutex> guard(m_mutex);
196 if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) &&
197 !m_frame_code_addr.IsSectionOffset()) {
198 m_flags.Set(RESOLVED_FRAME_CODE_ADDR);
199
200 // Resolve the PC into a temporary address because if ResolveLoadAddress
201 // fails to resolve the address, it will clear the address object...
202 ThreadSP thread_sp(GetThread());
203 if (thread_sp) {
204 TargetSP target_sp(thread_sp->CalculateTarget());
205 if (target_sp) {
206 const bool allow_section_end = true;
207 if (m_frame_code_addr.SetOpcodeLoadAddress(
208 load_addr: m_frame_code_addr.GetOffset(), target: target_sp.get(),
209 addr_class: AddressClass::eCode, allow_section_end)) {
210 ModuleSP module_sp(m_frame_code_addr.GetModule());
211 if (module_sp) {
212 m_sc.module_sp = module_sp;
213 m_flags.Set(eSymbolContextModule);
214 }
215 }
216 }
217 }
218 }
219 return m_frame_code_addr;
220}
221
222// This can't be rewritten into a call to
223// RegisterContext::GetPCForSymbolication because this
224// StackFrame may have been constructed with a special pc,
225// e.g. tail-call artificial frames.
226Address StackFrame::GetFrameCodeAddressForSymbolication() {
227 Address lookup_addr(GetFrameCodeAddress());
228 if (!lookup_addr.IsValid())
229 return lookup_addr;
230 if (m_behaves_like_zeroth_frame)
231 return lookup_addr;
232
233 addr_t offset = lookup_addr.GetOffset();
234 if (offset > 0) {
235 lookup_addr.SetOffset(offset - 1);
236 } else {
237 // lookup_addr is the start of a section. We need do the math on the
238 // actual load address and re-compute the section. We're working with
239 // a 'noreturn' function at the end of a section.
240 TargetSP target_sp = CalculateTarget();
241 if (target_sp) {
242 addr_t addr_minus_one = lookup_addr.GetOpcodeLoadAddress(
243 target: target_sp.get(), addr_class: AddressClass::eCode) -
244 1;
245 lookup_addr.SetOpcodeLoadAddress(load_addr: addr_minus_one, target: target_sp.get());
246 }
247 }
248 return lookup_addr;
249}
250
251bool StackFrame::ChangePC(addr_t pc) {
252 std::lock_guard<std::recursive_mutex> guard(m_mutex);
253 // We can't change the pc value of a history stack frame - it is immutable.
254 if (IsHistorical())
255 return false;
256 m_frame_code_addr.SetRawAddress(pc);
257 m_sc.Clear(clear_target: false);
258 m_flags.Reset(flags: 0);
259 ThreadSP thread_sp(GetThread());
260 if (thread_sp)
261 thread_sp->ClearStackFrames();
262 return true;
263}
264
265const char *StackFrame::Disassemble() {
266 std::lock_guard<std::recursive_mutex> guard(m_mutex);
267 if (!m_disassembly.Empty())
268 return m_disassembly.GetData();
269
270 ExecutionContext exe_ctx(shared_from_this());
271 if (Target *target = exe_ctx.GetTargetPtr()) {
272 Disassembler::Disassemble(debugger&: target->GetDebugger(), arch: target->GetArchitecture(),
273 frame&: *this, strm&: m_disassembly);
274 }
275
276 return m_disassembly.Empty() ? nullptr : m_disassembly.GetData();
277}
278
279Block *StackFrame::GetFrameBlock() {
280 if (m_sc.block == nullptr && m_flags.IsClear(bit: eSymbolContextBlock))
281 GetSymbolContext(resolve_scope: eSymbolContextBlock);
282
283 if (m_sc.block) {
284 Block *inline_block = m_sc.block->GetContainingInlinedBlock();
285 if (inline_block) {
286 // Use the block with the inlined function info as the frame block we
287 // want this frame to have only the variables for the inlined function
288 // and its non-inlined block child blocks.
289 return inline_block;
290 } else {
291 // This block is not contained within any inlined function blocks with so
292 // we want to use the top most function block.
293 return &m_sc.function->GetBlock(can_create: false);
294 }
295 }
296 return nullptr;
297}
298
299// Get the symbol context if we already haven't done so by resolving the
300// PC address as much as possible. This way when we pass around a
301// StackFrame object, everyone will have as much information as possible and no
302// one will ever have to look things up manually.
303const SymbolContext &
304StackFrame::GetSymbolContext(SymbolContextItem resolve_scope) {
305 std::lock_guard<std::recursive_mutex> guard(m_mutex);
306 // Copy our internal symbol context into "sc".
307 if ((m_flags.Get() & resolve_scope) != resolve_scope) {
308 uint32_t resolved = 0;
309
310 // If the target was requested add that:
311 if (!m_sc.target_sp) {
312 m_sc.target_sp = CalculateTarget();
313 if (m_sc.target_sp)
314 resolved |= eSymbolContextTarget;
315 }
316
317 // Resolve our PC to section offset if we haven't already done so and if we
318 // don't have a module. The resolved address section will contain the
319 // module to which it belongs
320 if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
321 GetFrameCodeAddress();
322
323 // If this is not frame zero, then we need to subtract 1 from the PC value
324 // when doing address lookups since the PC will be on the instruction
325 // following the function call instruction...
326 Address lookup_addr(GetFrameCodeAddressForSymbolication());
327
328 if (m_sc.module_sp) {
329 // We have something in our stack frame symbol context, lets check if we
330 // haven't already tried to lookup one of those things. If we haven't
331 // then we will do the query.
332
333 SymbolContextItem actual_resolve_scope = SymbolContextItem(0);
334
335 if (resolve_scope & eSymbolContextCompUnit) {
336 if (m_flags.IsClear(bit: eSymbolContextCompUnit)) {
337 if (m_sc.comp_unit)
338 resolved |= eSymbolContextCompUnit;
339 else
340 actual_resolve_scope |= eSymbolContextCompUnit;
341 }
342 }
343
344 if (resolve_scope & eSymbolContextFunction) {
345 if (m_flags.IsClear(bit: eSymbolContextFunction)) {
346 if (m_sc.function)
347 resolved |= eSymbolContextFunction;
348 else
349 actual_resolve_scope |= eSymbolContextFunction;
350 }
351 }
352
353 if (resolve_scope & eSymbolContextBlock) {
354 if (m_flags.IsClear(bit: eSymbolContextBlock)) {
355 if (m_sc.block)
356 resolved |= eSymbolContextBlock;
357 else
358 actual_resolve_scope |= eSymbolContextBlock;
359 }
360 }
361
362 if (resolve_scope & eSymbolContextSymbol) {
363 if (m_flags.IsClear(bit: eSymbolContextSymbol)) {
364 if (m_sc.symbol)
365 resolved |= eSymbolContextSymbol;
366 else
367 actual_resolve_scope |= eSymbolContextSymbol;
368 }
369 }
370
371 if (resolve_scope & eSymbolContextLineEntry) {
372 if (m_flags.IsClear(bit: eSymbolContextLineEntry)) {
373 if (m_sc.line_entry.IsValid())
374 resolved |= eSymbolContextLineEntry;
375 else
376 actual_resolve_scope |= eSymbolContextLineEntry;
377 }
378 }
379
380 if (actual_resolve_scope) {
381 // We might be resolving less information than what is already in our
382 // current symbol context so resolve into a temporary symbol context
383 // "sc" so we don't clear out data we have already found in "m_sc"
384 SymbolContext sc;
385 // Set flags that indicate what we have tried to resolve
386 resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
387 so_addr: lookup_addr, resolve_scope: actual_resolve_scope, sc);
388 // Only replace what we didn't already have as we may have information
389 // for an inlined function scope that won't match what a standard
390 // lookup by address would match
391 if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
392 m_sc.comp_unit = sc.comp_unit;
393 if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
394 m_sc.function = sc.function;
395 if ((resolved & eSymbolContextBlock) && m_sc.block == nullptr)
396 m_sc.block = sc.block;
397 if ((resolved & eSymbolContextSymbol) && m_sc.symbol == nullptr)
398 m_sc.symbol = sc.symbol;
399 if ((resolved & eSymbolContextLineEntry) &&
400 !m_sc.line_entry.IsValid()) {
401 m_sc.line_entry = sc.line_entry;
402 m_sc.line_entry.ApplyFileMappings(target_sp: m_sc.target_sp);
403 }
404 }
405 } else {
406 // If we don't have a module, then we can't have the compile unit,
407 // function, block, line entry or symbol, so we can safely call
408 // ResolveSymbolContextForAddress with our symbol context member m_sc.
409 if (m_sc.target_sp) {
410 resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
411 so_addr: lookup_addr, resolve_scope, sc&: m_sc);
412 }
413 }
414
415 // Update our internal flags so we remember what we have tried to locate so
416 // we don't have to keep trying when more calls to this function are made.
417 // We might have dug up more information that was requested (for example if
418 // we were asked to only get the block, we will have gotten the compile
419 // unit, and function) so set any additional bits that we resolved
420 m_flags.Set(resolve_scope | resolved);
421 }
422
423 // Return the symbol context with everything that was possible to resolve
424 // resolved.
425 return m_sc;
426}
427
428VariableList *StackFrame::GetVariableList(bool get_file_globals,
429 Status *error_ptr) {
430 std::lock_guard<std::recursive_mutex> guard(m_mutex);
431 if (m_flags.IsClear(RESOLVED_VARIABLES)) {
432 m_flags.Set(RESOLVED_VARIABLES);
433 m_variable_list_sp = std::make_shared<VariableList>();
434
435 Block *frame_block = GetFrameBlock();
436
437 if (frame_block) {
438 const bool get_child_variables = true;
439 const bool can_create = true;
440 const bool stop_if_child_block_is_inlined_function = true;
441 frame_block->AppendBlockVariables(can_create, get_child_block_variables: get_child_variables,
442 stop_if_child_block_is_inlined_function,
443 filter: [](Variable *v) { return true; },
444 variable_list: m_variable_list_sp.get());
445 }
446 }
447
448 if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
449 m_flags.Set(RESOLVED_GLOBAL_VARIABLES);
450
451 if (m_flags.IsClear(bit: eSymbolContextCompUnit))
452 GetSymbolContext(resolve_scope: eSymbolContextCompUnit);
453
454 if (m_sc.comp_unit) {
455 VariableListSP global_variable_list_sp(
456 m_sc.comp_unit->GetVariableList(can_create: true));
457 if (m_variable_list_sp)
458 m_variable_list_sp->AddVariables(variable_list: global_variable_list_sp.get());
459 else
460 m_variable_list_sp = global_variable_list_sp;
461 }
462 }
463
464 if (error_ptr && m_variable_list_sp->GetSize() == 0) {
465 // Check with the symbol file to check if there is an error for why we
466 // don't have variables that the user might need to know about.
467 GetSymbolContext(resolve_scope: eSymbolContextEverything);
468 if (m_sc.module_sp) {
469 SymbolFile *sym_file = m_sc.module_sp->GetSymbolFile();
470 if (sym_file)
471 *error_ptr = sym_file->GetFrameVariableError(frame&: *this);
472 }
473 }
474
475 return m_variable_list_sp.get();
476}
477
478VariableListSP
479StackFrame::GetInScopeVariableList(bool get_file_globals,
480 bool must_have_valid_location) {
481 std::lock_guard<std::recursive_mutex> guard(m_mutex);
482 // We can't fetch variable information for a history stack frame.
483 if (IsHistorical())
484 return VariableListSP();
485
486 VariableListSP var_list_sp(new VariableList);
487 GetSymbolContext(resolve_scope: eSymbolContextCompUnit | eSymbolContextBlock);
488
489 if (m_sc.block) {
490 const bool can_create = true;
491 const bool get_parent_variables = true;
492 const bool stop_if_block_is_inlined_function = true;
493 m_sc.block->AppendVariables(
494 can_create, get_parent_variables, stop_if_block_is_inlined_function,
495 filter: [this, must_have_valid_location](Variable *v) {
496 return v->IsInScope(frame: this) && (!must_have_valid_location ||
497 v->LocationIsValidForFrame(frame: this));
498 },
499 variable_list: var_list_sp.get());
500 }
501
502 if (m_sc.comp_unit && get_file_globals) {
503 VariableListSP global_variable_list_sp(
504 m_sc.comp_unit->GetVariableList(can_create: true));
505 if (global_variable_list_sp)
506 var_list_sp->AddVariables(variable_list: global_variable_list_sp.get());
507 }
508
509 return var_list_sp;
510}
511
512ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
513 llvm::StringRef var_expr, DynamicValueType use_dynamic, uint32_t options,
514 VariableSP &var_sp, Status &error) {
515 ExecutionContext exe_ctx;
516 CalculateExecutionContext(exe_ctx);
517 bool use_DIL = exe_ctx.GetTargetRef().GetUseDIL(exe_ctx: &exe_ctx);
518 if (use_DIL)
519 return DILGetValueForVariableExpressionPath(var_expr, use_dynamic, options,
520 var_sp, error);
521
522 return LegacyGetValueForVariableExpressionPath(var_expr, use_dynamic, options,
523 var_sp, error);
524}
525
526ValueObjectSP StackFrame::DILGetValueForVariableExpressionPath(
527 llvm::StringRef var_expr, lldb::DynamicValueType use_dynamic,
528 uint32_t options, lldb::VariableSP &var_sp, Status &error) {
529
530 const bool check_ptr_vs_member =
531 (options & eExpressionPathOptionCheckPtrVsMember) != 0;
532 const bool no_fragile_ivar =
533 (options & eExpressionPathOptionsNoFragileObjcIvar) != 0;
534 const bool no_synth_child =
535 (options & eExpressionPathOptionsNoSyntheticChildren) != 0;
536
537 // Lex the expression.
538 auto lex_or_err = dil::DILLexer::Create(expr: var_expr);
539 if (!lex_or_err) {
540 error = Status::FromError(error: lex_or_err.takeError());
541 return ValueObjectConstResult::Create(exe_scope: nullptr, error: std::move(error));
542 }
543
544 // Parse the expression.
545 auto tree_or_error = dil::DILParser::Parse(
546 dil_input_expr: var_expr, lexer: std::move(*lex_or_err), frame_sp: shared_from_this(), use_dynamic,
547 use_synthetic: !no_synth_child, fragile_ivar: !no_fragile_ivar, check_ptr_vs_member);
548 if (!tree_or_error) {
549 error = Status::FromError(error: tree_or_error.takeError());
550 return ValueObjectConstResult::Create(exe_scope: nullptr, error: std::move(error));
551 }
552
553 // Evaluate the parsed expression.
554 lldb::TargetSP target = this->CalculateTarget();
555 dil::Interpreter interpreter(target, var_expr, shared_from_this(),
556 use_dynamic, !no_synth_child, !no_fragile_ivar,
557 check_ptr_vs_member);
558
559 auto valobj_or_error = interpreter.Evaluate(node: (*tree_or_error).get());
560 if (!valobj_or_error) {
561 error = Status::FromError(error: valobj_or_error.takeError());
562 return ValueObjectConstResult::Create(exe_scope: nullptr, error: std::move(error));
563 }
564
565 return *valobj_or_error;
566}
567
568ValueObjectSP StackFrame::LegacyGetValueForVariableExpressionPath(
569 llvm::StringRef var_expr, DynamicValueType use_dynamic, uint32_t options,
570 VariableSP &var_sp, Status &error) {
571 llvm::StringRef original_var_expr = var_expr;
572 // We can't fetch variable information for a history stack frame.
573 if (IsHistorical())
574 return ValueObjectSP();
575
576 if (var_expr.empty()) {
577 error = Status::FromErrorStringWithFormatv(format: "invalid variable path '{0}'",
578 args&: var_expr);
579 return ValueObjectSP();
580 }
581
582 const bool check_ptr_vs_member =
583 (options & eExpressionPathOptionCheckPtrVsMember) != 0;
584 const bool no_fragile_ivar =
585 (options & eExpressionPathOptionsNoFragileObjcIvar) != 0;
586 const bool no_synth_child =
587 (options & eExpressionPathOptionsNoSyntheticChildren) != 0;
588 // const bool no_synth_array = (options &
589 // eExpressionPathOptionsNoSyntheticArrayRange) != 0;
590 error.Clear();
591 bool deref = false;
592 bool address_of = false;
593 ValueObjectSP valobj_sp;
594 const bool get_file_globals = true;
595 // When looking up a variable for an expression, we need only consider the
596 // variables that are in scope.
597 VariableListSP var_list_sp(GetInScopeVariableList(get_file_globals));
598 VariableList *variable_list = var_list_sp.get();
599
600 if (!variable_list)
601 return ValueObjectSP();
602
603 // If first character is a '*', then show pointer contents
604 std::string var_expr_storage;
605 if (var_expr[0] == '*') {
606 deref = true;
607 var_expr = var_expr.drop_front(); // Skip the '*'
608 } else if (var_expr[0] == '&') {
609 address_of = true;
610 var_expr = var_expr.drop_front(); // Skip the '&'
611 }
612
613 size_t separator_idx = var_expr.find_first_of(Chars: ".-[=+~|&^%#@!/?,<>{}");
614 StreamString var_expr_path_strm;
615
616 ConstString name_const_string(var_expr.substr(Start: 0, N: separator_idx));
617
618 var_sp = variable_list->FindVariable(name: name_const_string, include_static_members: false);
619
620 bool synthetically_added_instance_object = false;
621
622 if (var_sp) {
623 var_expr = var_expr.drop_front(N: name_const_string.GetLength());
624 }
625
626 if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
627 // Check for direct ivars access which helps us with implicit access to
628 // ivars using "this" or "self".
629 GetSymbolContext(resolve_scope: eSymbolContextFunction | eSymbolContextBlock);
630 llvm::StringRef instance_var_name = m_sc.GetInstanceVariableName();
631 if (!instance_var_name.empty()) {
632 var_sp = variable_list->FindVariable(name: ConstString(instance_var_name));
633 if (var_sp) {
634 separator_idx = 0;
635 if (Type *var_type = var_sp->GetType())
636 if (auto compiler_type = var_type->GetForwardCompilerType())
637 if (!compiler_type.IsPointerType())
638 var_expr_storage = ".";
639
640 if (var_expr_storage.empty())
641 var_expr_storage = "->";
642 var_expr_storage += var_expr;
643 var_expr = var_expr_storage;
644 synthetically_added_instance_object = true;
645 }
646 }
647 }
648
649 if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
650 // Check if any anonymous unions are there which contain a variable with
651 // the name we need
652 for (const VariableSP &variable_sp : *variable_list) {
653 if (!variable_sp)
654 continue;
655 if (!variable_sp->GetName().IsEmpty())
656 continue;
657
658 Type *var_type = variable_sp->GetType();
659 if (!var_type)
660 continue;
661
662 if (!var_type->GetForwardCompilerType().IsAnonymousType())
663 continue;
664 valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
665 if (!valobj_sp)
666 return valobj_sp;
667 valobj_sp = valobj_sp->GetChildMemberWithName(name: name_const_string);
668 if (valobj_sp)
669 break;
670 }
671 }
672
673 if (var_sp && !valobj_sp) {
674 valobj_sp = GetValueObjectForFrameVariable(variable_sp: var_sp, use_dynamic);
675 if (!valobj_sp)
676 return valobj_sp;
677 }
678 if (!valobj_sp) {
679 error = Status::FromErrorStringWithFormatv(
680 format: "no variable named '{0}' found in this frame", args&: name_const_string);
681 return ValueObjectSP();
682 }
683
684 // We are dumping at least one child
685 while (!var_expr.empty()) {
686 // Calculate the next separator index ahead of time
687 ValueObjectSP child_valobj_sp;
688 const char separator_type = var_expr[0];
689 bool expr_is_ptr = false;
690 switch (separator_type) {
691 case '-':
692 expr_is_ptr = true;
693 if (var_expr.size() >= 2 && var_expr[1] != '>')
694 return ValueObjectSP();
695
696 if (no_fragile_ivar) {
697 // Make sure we aren't trying to deref an objective
698 // C ivar if this is not allowed
699 const uint32_t pointer_type_flags =
700 valobj_sp->GetCompilerType().GetTypeInfo(pointee_or_element_compiler_type: nullptr);
701 if ((pointer_type_flags & eTypeIsObjC) &&
702 (pointer_type_flags & eTypeIsPointer)) {
703 // This was an objective C object pointer and it was requested we
704 // skip any fragile ivars so return nothing here
705 return ValueObjectSP();
706 }
707 }
708
709 // If we have a non-pointer type with a synthetic value then lets check if
710 // we have a synthetic dereference specified.
711 if (!valobj_sp->IsPointerType() && valobj_sp->HasSyntheticValue()) {
712 Status deref_error;
713 if (ValueObjectSP synth_deref_sp =
714 valobj_sp->GetSyntheticValue()->Dereference(error&: deref_error);
715 synth_deref_sp && deref_error.Success()) {
716 valobj_sp = std::move(synth_deref_sp);
717 }
718 if (!valobj_sp || deref_error.Fail()) {
719 error = Status::FromErrorStringWithFormatv(
720 format: "Failed to dereference synthetic value: {0}", args&: deref_error);
721 return ValueObjectSP();
722 }
723
724 // Some synthetic plug-ins fail to set the error in Dereference
725 if (!valobj_sp) {
726 error =
727 Status::FromErrorString(str: "Failed to dereference synthetic value");
728 return ValueObjectSP();
729 }
730 expr_is_ptr = false;
731 }
732
733 var_expr = var_expr.drop_front(); // Remove the '-'
734 [[fallthrough]];
735 case '.': {
736 var_expr = var_expr.drop_front(); // Remove the '.' or '>'
737 separator_idx = var_expr.find_first_of(Chars: ".-[");
738 ConstString child_name(var_expr.substr(Start: 0, N: var_expr.find_first_of(Chars: ".-[")));
739
740 if (check_ptr_vs_member) {
741 // We either have a pointer type and need to verify valobj_sp is a
742 // pointer, or we have a member of a class/union/struct being accessed
743 // with the . syntax and need to verify we don't have a pointer.
744 const bool actual_is_ptr = valobj_sp->IsPointerType();
745
746 if (actual_is_ptr != expr_is_ptr) {
747 // Incorrect use of "." with a pointer, or "->" with a
748 // class/union/struct instance or reference.
749 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
750 if (actual_is_ptr)
751 error = Status::FromErrorStringWithFormat(
752 format: "\"%s\" is a pointer and . was used to attempt to access "
753 "\"%s\". Did you mean \"%s->%s\"?",
754 var_expr_path_strm.GetData(), child_name.GetCString(),
755 var_expr_path_strm.GetData(), var_expr.str().c_str());
756 else
757 error = Status::FromErrorStringWithFormat(
758 format: "\"%s\" is not a pointer and -> was used to attempt to "
759 "access \"%s\". Did you mean \"%s.%s\"?",
760 var_expr_path_strm.GetData(), child_name.GetCString(),
761 var_expr_path_strm.GetData(), var_expr.str().c_str());
762 return ValueObjectSP();
763 }
764 }
765 child_valobj_sp = valobj_sp->GetChildMemberWithName(name: child_name);
766 if (!child_valobj_sp) {
767 if (!no_synth_child) {
768 child_valobj_sp = valobj_sp->GetSyntheticValue();
769 if (child_valobj_sp)
770 child_valobj_sp =
771 child_valobj_sp->GetChildMemberWithName(name: child_name);
772 }
773
774 if (no_synth_child || !child_valobj_sp) {
775 // No child member with name "child_name"
776 if (synthetically_added_instance_object) {
777 // We added a "this->" or "self->" to the beginning of the
778 // expression and this is the first pointer ivar access, so just
779 // return the normal error
780 error = Status::FromErrorStringWithFormat(
781 format: "no variable or instance variable named '%s' found in "
782 "this frame",
783 name_const_string.GetCString());
784 } else {
785 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
786 if (child_name) {
787 error = Status::FromErrorStringWithFormat(
788 format: "\"%s\" is not a member of \"(%s) %s\"",
789 child_name.GetCString(),
790 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
791 var_expr_path_strm.GetData());
792 } else {
793 error = Status::FromErrorStringWithFormat(
794 format: "incomplete expression path after \"%s\" in \"%s\"",
795 var_expr_path_strm.GetData(),
796 original_var_expr.str().c_str());
797 }
798 }
799 return ValueObjectSP();
800 }
801 }
802 synthetically_added_instance_object = false;
803 // Remove the child name from the path
804 var_expr = var_expr.drop_front(N: child_name.GetLength());
805 if (use_dynamic != eNoDynamicValues) {
806 ValueObjectSP dynamic_value_sp(
807 child_valobj_sp->GetDynamicValue(valueType: use_dynamic));
808 if (dynamic_value_sp)
809 child_valobj_sp = dynamic_value_sp;
810 }
811 } break;
812
813 case '[': {
814 // Array member access, or treating pointer as an array Need at least two
815 // brackets and a number
816 if (var_expr.size() <= 2) {
817 error = Status::FromErrorStringWithFormat(
818 format: "invalid square bracket encountered after \"%s\" in \"%s\"",
819 var_expr_path_strm.GetData(), var_expr.str().c_str());
820 return ValueObjectSP();
821 }
822
823 // Drop the open brace.
824 var_expr = var_expr.drop_front();
825 long child_index = 0;
826
827 // If there's no closing brace, this is an invalid expression.
828 size_t end_pos = var_expr.find_first_of(C: ']');
829 if (end_pos == llvm::StringRef::npos) {
830 error = Status::FromErrorStringWithFormat(
831 format: "missing closing square bracket in expression \"%s\"",
832 var_expr_path_strm.GetData());
833 return ValueObjectSP();
834 }
835 llvm::StringRef index_expr = var_expr.take_front(N: end_pos);
836 llvm::StringRef original_index_expr = index_expr;
837 // Drop all of "[index_expr]"
838 var_expr = var_expr.drop_front(N: end_pos + 1);
839
840 if (index_expr.consumeInteger(Radix: 0, Result&: child_index)) {
841 // If there was no integer anywhere in the index expression, this is
842 // erroneous expression.
843 error = Status::FromErrorStringWithFormat(
844 format: "invalid index expression \"%s\"", index_expr.str().c_str());
845 return ValueObjectSP();
846 }
847
848 if (index_expr.empty()) {
849 // The entire index expression was a single integer.
850
851 if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
852 // what we have is *ptr[low]. the most similar C++ syntax is to deref
853 // ptr and extract bit low out of it. reading array item low would be
854 // done by saying ptr[low], without a deref * sign
855 Status deref_error;
856 ValueObjectSP temp(valobj_sp->Dereference(error&: deref_error));
857 if (!temp || deref_error.Fail()) {
858 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
859 error = Status::FromErrorStringWithFormat(
860 format: "could not dereference \"(%s) %s\"",
861 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
862 var_expr_path_strm.GetData());
863 return ValueObjectSP();
864 }
865 valobj_sp = temp;
866 deref = false;
867 } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
868 deref) {
869 // what we have is *arr[low]. the most similar C++ syntax is to get
870 // arr[0] (an operation that is equivalent to deref-ing arr) and
871 // extract bit low out of it. reading array item low would be done by
872 // saying arr[low], without a deref * sign
873 ValueObjectSP temp(valobj_sp->GetChildAtIndex(idx: 0));
874 if (!temp) {
875 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
876 error = Status::FromErrorStringWithFormat(
877 format: "could not get item 0 for \"(%s) %s\"",
878 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
879 var_expr_path_strm.GetData());
880 return ValueObjectSP();
881 }
882 valobj_sp = temp;
883 deref = false;
884 }
885
886 bool is_incomplete_array = false;
887 if (valobj_sp->IsPointerType()) {
888 bool is_objc_pointer = true;
889
890 if (valobj_sp->GetCompilerType().GetMinimumLanguage() !=
891 eLanguageTypeObjC)
892 is_objc_pointer = false;
893 else if (!valobj_sp->GetCompilerType().IsPointerType())
894 is_objc_pointer = false;
895
896 if (no_synth_child && is_objc_pointer) {
897 error = Status::FromErrorStringWithFormat(
898 format: "\"(%s) %s\" is an Objective-C pointer, and cannot be "
899 "subscripted",
900 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
901 var_expr_path_strm.GetData());
902
903 return ValueObjectSP();
904 } else if (is_objc_pointer) {
905 // dereferencing ObjC variables is not valid.. so let's try and
906 // recur to synthetic children
907 ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
908 if (!synthetic /* no synthetic */
909 || synthetic == valobj_sp) /* synthetic is the same as
910 the original object */
911 {
912 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
913 error = Status::FromErrorStringWithFormat(
914 format: "\"(%s) %s\" is not an array type",
915 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
916 var_expr_path_strm.GetData());
917 } else if (static_cast<uint32_t>(child_index) >=
918 synthetic
919 ->GetNumChildrenIgnoringErrors() /* synthetic does
920 not have that
921 many values */) {
922 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
923 error = Status::FromErrorStringWithFormat(
924 format: "array index %ld is not valid for \"(%s) %s\"", child_index,
925 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
926 var_expr_path_strm.GetData());
927 } else {
928 child_valobj_sp = synthetic->GetChildAtIndex(idx: child_index);
929 if (!child_valobj_sp) {
930 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
931 error = Status::FromErrorStringWithFormat(
932 format: "array index %ld is not valid for \"(%s) %s\"", child_index,
933 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
934 var_expr_path_strm.GetData());
935 }
936 }
937 } else {
938 child_valobj_sp =
939 valobj_sp->GetSyntheticArrayMember(index: child_index, can_create: true);
940 if (!child_valobj_sp) {
941 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
942 error = Status::FromErrorStringWithFormat(
943 format: "failed to use pointer as array for index %ld for "
944 "\"(%s) %s\"",
945 child_index,
946 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
947 var_expr_path_strm.GetData());
948 }
949 }
950 } else if (valobj_sp->GetCompilerType().IsArrayType(
951 element_type: nullptr, size: nullptr, is_incomplete: &is_incomplete_array)) {
952 // Pass false to dynamic_value here so we can tell the difference
953 // between no dynamic value and no member of this type...
954 child_valobj_sp = valobj_sp->GetChildAtIndex(idx: child_index);
955 if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
956 child_valobj_sp =
957 valobj_sp->GetSyntheticArrayMember(index: child_index, can_create: true);
958
959 if (!child_valobj_sp) {
960 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
961 error = Status::FromErrorStringWithFormat(
962 format: "array index %ld is not valid for \"(%s) %s\"", child_index,
963 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
964 var_expr_path_strm.GetData());
965 }
966 } else if (valobj_sp->GetCompilerType().IsScalarType()) {
967 // this is a bitfield asking to display just one bit
968 child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
969 from: child_index, to: child_index, can_create: true);
970 if (!child_valobj_sp) {
971 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
972 error = Status::FromErrorStringWithFormat(
973 format: "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
974 child_index, child_index,
975 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
976 var_expr_path_strm.GetData());
977 }
978 } else {
979 ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
980 if (no_synth_child /* synthetic is forbidden */ ||
981 !synthetic /* no synthetic */
982 || synthetic == valobj_sp) /* synthetic is the same as the
983 original object */
984 {
985 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
986 error = Status::FromErrorStringWithFormat(
987 format: "\"(%s) %s\" is not an array type",
988 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
989 var_expr_path_strm.GetData());
990 } else if (static_cast<uint32_t>(child_index) >=
991 synthetic->GetNumChildrenIgnoringErrors() /* synthetic
992 does not have that many values */) {
993 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
994 error = Status::FromErrorStringWithFormat(
995 format: "array index %ld is not valid for \"(%s) %s\"", child_index,
996 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
997 var_expr_path_strm.GetData());
998 } else {
999 child_valobj_sp = synthetic->GetChildAtIndex(idx: child_index);
1000 if (!child_valobj_sp) {
1001 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
1002 error = Status::FromErrorStringWithFormat(
1003 format: "array index %ld is not valid for \"(%s) %s\"", child_index,
1004 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
1005 var_expr_path_strm.GetData());
1006 }
1007 }
1008 }
1009
1010 if (!child_valobj_sp) {
1011 // Invalid array index...
1012 return ValueObjectSP();
1013 }
1014
1015 if (use_dynamic != eNoDynamicValues) {
1016 ValueObjectSP dynamic_value_sp(
1017 child_valobj_sp->GetDynamicValue(valueType: use_dynamic));
1018 if (dynamic_value_sp)
1019 child_valobj_sp = dynamic_value_sp;
1020 }
1021 // Break out early from the switch since we were able to find the child
1022 // member
1023 break;
1024 }
1025
1026 // this is most probably a BitField, let's take a look
1027 if (index_expr.front() != '-') {
1028 error = Status::FromErrorStringWithFormat(
1029 format: "invalid range expression \"'%s'\"",
1030 original_index_expr.str().c_str());
1031 return ValueObjectSP();
1032 }
1033
1034 index_expr = index_expr.drop_front();
1035 long final_index = 0;
1036 if (index_expr.getAsInteger(Radix: 0, Result&: final_index)) {
1037 error = Status::FromErrorStringWithFormat(
1038 format: "invalid range expression \"'%s'\"",
1039 original_index_expr.str().c_str());
1040 return ValueObjectSP();
1041 }
1042
1043 // if the format given is [high-low], swap range
1044 if (child_index > final_index) {
1045 long temp = child_index;
1046 child_index = final_index;
1047 final_index = temp;
1048 }
1049
1050 if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
1051 // what we have is *ptr[low-high]. the most similar C++ syntax is to
1052 // deref ptr and extract bits low thru high out of it. reading array
1053 // items low thru high would be done by saying ptr[low-high], without a
1054 // deref * sign
1055 Status deref_error;
1056 ValueObjectSP temp(valobj_sp->Dereference(error&: deref_error));
1057 if (!temp || deref_error.Fail()) {
1058 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
1059 error = Status::FromErrorStringWithFormat(
1060 format: "could not dereference \"(%s) %s\"",
1061 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
1062 var_expr_path_strm.GetData());
1063 return ValueObjectSP();
1064 }
1065 valobj_sp = temp;
1066 deref = false;
1067 } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref) {
1068 // what we have is *arr[low-high]. the most similar C++ syntax is to
1069 // get arr[0] (an operation that is equivalent to deref-ing arr) and
1070 // extract bits low thru high out of it. reading array items low thru
1071 // high would be done by saying arr[low-high], without a deref * sign
1072 ValueObjectSP temp(valobj_sp->GetChildAtIndex(idx: 0));
1073 if (!temp) {
1074 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
1075 error = Status::FromErrorStringWithFormat(
1076 format: "could not get item 0 for \"(%s) %s\"",
1077 valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
1078 var_expr_path_strm.GetData());
1079 return ValueObjectSP();
1080 }
1081 valobj_sp = temp;
1082 deref = false;
1083 }
1084
1085 child_valobj_sp =
1086 valobj_sp->GetSyntheticBitFieldChild(from: child_index, to: final_index, can_create: true);
1087 if (!child_valobj_sp) {
1088 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
1089 error = Status::FromErrorStringWithFormat(
1090 format: "bitfield range %ld-%ld is not valid for \"(%s) %s\"", child_index,
1091 final_index, valobj_sp->GetTypeName().AsCString(value_if_empty: "<invalid type>"),
1092 var_expr_path_strm.GetData());
1093 }
1094
1095 if (!child_valobj_sp) {
1096 // Invalid bitfield range...
1097 return ValueObjectSP();
1098 }
1099
1100 if (use_dynamic != eNoDynamicValues) {
1101 ValueObjectSP dynamic_value_sp(
1102 child_valobj_sp->GetDynamicValue(valueType: use_dynamic));
1103 if (dynamic_value_sp)
1104 child_valobj_sp = dynamic_value_sp;
1105 }
1106 // Break out early from the switch since we were able to find the child
1107 // member
1108 break;
1109 }
1110 default:
1111 // Failure...
1112 {
1113 valobj_sp->GetExpressionPath(s&: var_expr_path_strm);
1114 error = Status::FromErrorStringWithFormat(
1115 format: "unexpected char '%c' encountered after \"%s\" in \"%s\"",
1116 separator_type, var_expr_path_strm.GetData(),
1117 var_expr.str().c_str());
1118
1119 return ValueObjectSP();
1120 }
1121 }
1122
1123 if (child_valobj_sp)
1124 valobj_sp = child_valobj_sp;
1125 }
1126 if (valobj_sp) {
1127 if (deref) {
1128 ValueObjectSP deref_valobj_sp(valobj_sp->Dereference(error));
1129 if (!deref_valobj_sp && !no_synth_child) {
1130 if (ValueObjectSP synth_obj_sp = valobj_sp->GetSyntheticValue()) {
1131 error.Clear();
1132 deref_valobj_sp = synth_obj_sp->Dereference(error);
1133 }
1134 }
1135 valobj_sp = deref_valobj_sp;
1136 } else if (address_of) {
1137 ValueObjectSP address_of_valobj_sp(valobj_sp->AddressOf(error));
1138 valobj_sp = address_of_valobj_sp;
1139 }
1140 }
1141 return valobj_sp;
1142}
1143
1144llvm::Error StackFrame::GetFrameBaseValue(Scalar &frame_base) {
1145 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1146 if (!m_cfa_is_valid) {
1147 m_frame_base_error = Status::FromErrorString(
1148 str: "No frame base available for this historical stack frame.");
1149 return m_frame_base_error.ToError();
1150 }
1151
1152 if (m_flags.IsClear(GOT_FRAME_BASE)) {
1153 if (m_sc.function) {
1154 m_frame_base.Clear();
1155 m_frame_base_error.Clear();
1156
1157 m_flags.Set(GOT_FRAME_BASE);
1158 ExecutionContext exe_ctx(shared_from_this());
1159 addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
1160 if (!m_sc.function->GetFrameBaseExpression().IsAlwaysValidSingleExpr())
1161 loclist_base_addr =
1162 m_sc.function->GetAddress().GetLoadAddress(target: exe_ctx.GetTargetPtr());
1163
1164 llvm::Expected<Value> expr_value =
1165 m_sc.function->GetFrameBaseExpression().Evaluate(
1166 exe_ctx: &exe_ctx, reg_ctx: nullptr, func_load_addr: loclist_base_addr, initial_value_ptr: nullptr, object_address_ptr: nullptr);
1167 if (!expr_value)
1168 m_frame_base_error = Status::FromError(error: expr_value.takeError());
1169 else
1170 m_frame_base = expr_value->ResolveValue(exe_ctx: &exe_ctx);
1171 } else {
1172 m_frame_base_error =
1173 Status::FromErrorString(str: "No function in symbol context.");
1174 }
1175 }
1176
1177 if (m_frame_base_error.Fail())
1178 return m_frame_base_error.ToError();
1179
1180 frame_base = m_frame_base;
1181 return llvm::Error::success();
1182}
1183
1184DWARFExpressionList *StackFrame::GetFrameBaseExpression(Status *error_ptr) {
1185 if (!m_sc.function) {
1186 if (error_ptr) {
1187 *error_ptr = Status::FromErrorString(str: "No function in symbol context.");
1188 }
1189 return nullptr;
1190 }
1191
1192 return &m_sc.function->GetFrameBaseExpression();
1193}
1194
1195RegisterContextSP StackFrame::GetRegisterContext() {
1196 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1197 if (!m_reg_context_sp) {
1198 ThreadSP thread_sp(GetThread());
1199 if (thread_sp)
1200 m_reg_context_sp = thread_sp->CreateRegisterContextForFrame(frame: this);
1201 }
1202 return m_reg_context_sp;
1203}
1204
1205bool StackFrame::HasDebugInformation() {
1206 GetSymbolContext(resolve_scope: eSymbolContextLineEntry);
1207 return m_sc.line_entry.IsValid();
1208}
1209
1210ValueObjectSP
1211StackFrame::GetValueObjectForFrameVariable(const VariableSP &variable_sp,
1212 DynamicValueType use_dynamic) {
1213 ValueObjectSP valobj_sp;
1214 { // Scope for stack frame mutex. We need to drop this mutex before we figure
1215 // out the dynamic value. That will require converting the StackID in the
1216 // VO back to a StackFrame, which will in turn require locking the
1217 // StackFrameList. If we still hold the StackFrame mutex, we could suffer
1218 // lock inversion against the pattern of getting the StackFrameList and
1219 // then the stack frame, which is fairly common.
1220 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1221 if (IsHistorical()) {
1222 return valobj_sp;
1223 }
1224 VariableList *var_list = GetVariableList(get_file_globals: true, error_ptr: nullptr);
1225 if (var_list) {
1226 // Make sure the variable is a frame variable
1227 const uint32_t var_idx = var_list->FindIndexForVariable(variable: variable_sp.get());
1228 const uint32_t num_variables = var_list->GetSize();
1229 if (var_idx < num_variables) {
1230 valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex(idx: var_idx);
1231 if (!valobj_sp) {
1232 if (m_variable_list_value_objects.GetSize() < num_variables)
1233 m_variable_list_value_objects.Resize(size: num_variables);
1234 valobj_sp = ValueObjectVariable::Create(exe_scope: this, var_sp: variable_sp);
1235 m_variable_list_value_objects.SetValueObjectAtIndex(idx: var_idx,
1236 valobj_sp);
1237 }
1238 }
1239 }
1240 } // End of StackFrame mutex scope.
1241 if (use_dynamic != eNoDynamicValues && valobj_sp) {
1242 ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue(valueType: use_dynamic);
1243 if (dynamic_sp)
1244 return dynamic_sp;
1245 }
1246 return valobj_sp;
1247}
1248
1249bool StackFrame::IsInlined() {
1250 if (m_sc.block == nullptr)
1251 GetSymbolContext(resolve_scope: eSymbolContextBlock);
1252 if (m_sc.block)
1253 return m_sc.block->GetContainingInlinedBlock() != nullptr;
1254 return false;
1255}
1256
1257bool StackFrame::IsHistorical() const {
1258 return m_stack_frame_kind == StackFrame::Kind::History;
1259}
1260
1261bool StackFrame::IsArtificial() const {
1262 return m_stack_frame_kind == StackFrame::Kind::Artificial;
1263}
1264
1265bool StackFrame::IsHidden() {
1266 if (auto recognized_frame_sp = GetRecognizedFrame())
1267 return recognized_frame_sp->ShouldHide();
1268 return false;
1269}
1270
1271StructuredData::ObjectSP StackFrame::GetLanguageSpecificData() {
1272 auto process_sp = CalculateProcess();
1273 SourceLanguage language = GetLanguage();
1274 if (!language)
1275 return {};
1276 if (auto runtime_sp =
1277 process_sp->GetLanguageRuntime(language: language.AsLanguageType()))
1278 return runtime_sp->GetLanguageSpecificData(
1279 sc: GetSymbolContext(resolve_scope: eSymbolContextFunction));
1280 return {};
1281}
1282
1283const char *StackFrame::GetFunctionName() {
1284 const char *name = nullptr;
1285 SymbolContext sc = GetSymbolContext(
1286 resolve_scope: eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol);
1287 if (sc.block) {
1288 Block *inlined_block = sc.block->GetContainingInlinedBlock();
1289 if (inlined_block) {
1290 const InlineFunctionInfo *inlined_info =
1291 inlined_block->GetInlinedFunctionInfo();
1292 if (inlined_info)
1293 name = inlined_info->GetName().AsCString();
1294 }
1295 }
1296
1297 if (name == nullptr) {
1298 if (sc.function)
1299 name = sc.function->GetName().GetCString();
1300 }
1301
1302 if (name == nullptr) {
1303 if (sc.symbol)
1304 name = sc.symbol->GetName().GetCString();
1305 }
1306
1307 return name;
1308}
1309
1310const char *StackFrame::GetDisplayFunctionName() {
1311 const char *name = nullptr;
1312 SymbolContext sc = GetSymbolContext(
1313 resolve_scope: eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol);
1314 if (sc.block) {
1315 Block *inlined_block = sc.block->GetContainingInlinedBlock();
1316 if (inlined_block) {
1317 const InlineFunctionInfo *inlined_info =
1318 inlined_block->GetInlinedFunctionInfo();
1319 if (inlined_info)
1320 name = inlined_info->GetDisplayName().AsCString();
1321 }
1322 }
1323
1324 if (name == nullptr) {
1325 if (sc.function)
1326 name = sc.function->GetDisplayName().GetCString();
1327 }
1328
1329 if (name == nullptr) {
1330 if (sc.symbol)
1331 name = sc.symbol->GetDisplayName().GetCString();
1332 }
1333 return name;
1334}
1335
1336SourceLanguage StackFrame::GetLanguage() {
1337 CompileUnit *cu = GetSymbolContext(resolve_scope: eSymbolContextCompUnit).comp_unit;
1338 if (cu)
1339 return cu->GetLanguage();
1340 return {};
1341}
1342
1343SourceLanguage StackFrame::GuessLanguage() {
1344 SourceLanguage lang_type = GetLanguage();
1345
1346 if (lang_type == eLanguageTypeUnknown) {
1347 SymbolContext sc =
1348 GetSymbolContext(resolve_scope: eSymbolContextFunction | eSymbolContextSymbol);
1349 if (sc.function)
1350 lang_type = LanguageType(sc.function->GetMangled().GuessLanguage());
1351 else if (sc.symbol)
1352 lang_type = SourceLanguage(sc.symbol->GetMangled().GuessLanguage());
1353 }
1354
1355 return lang_type;
1356}
1357
1358namespace {
1359std::pair<const Instruction::Operand *, int64_t>
1360GetBaseExplainingValue(const Instruction::Operand &operand,
1361 RegisterContext &register_context, lldb::addr_t value) {
1362 switch (operand.m_type) {
1363 case Instruction::Operand::Type::Dereference:
1364 case Instruction::Operand::Type::Immediate:
1365 case Instruction::Operand::Type::Invalid:
1366 case Instruction::Operand::Type::Product:
1367 // These are not currently interesting
1368 return std::make_pair(x: nullptr, y: 0);
1369 case Instruction::Operand::Type::Sum: {
1370 const Instruction::Operand *immediate_child = nullptr;
1371 const Instruction::Operand *variable_child = nullptr;
1372 if (operand.m_children[0].m_type == Instruction::Operand::Type::Immediate) {
1373 immediate_child = &operand.m_children[0];
1374 variable_child = &operand.m_children[1];
1375 } else if (operand.m_children[1].m_type ==
1376 Instruction::Operand::Type::Immediate) {
1377 immediate_child = &operand.m_children[1];
1378 variable_child = &operand.m_children[0];
1379 }
1380 if (!immediate_child) {
1381 return std::make_pair(x: nullptr, y: 0);
1382 }
1383 lldb::addr_t adjusted_value = value;
1384 if (immediate_child->m_negative) {
1385 adjusted_value += immediate_child->m_immediate;
1386 } else {
1387 adjusted_value -= immediate_child->m_immediate;
1388 }
1389 std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1390 GetBaseExplainingValue(operand: *variable_child, register_context,
1391 value: adjusted_value);
1392 if (!base_and_offset.first) {
1393 return std::make_pair(x: nullptr, y: 0);
1394 }
1395 if (immediate_child->m_negative) {
1396 base_and_offset.second -= immediate_child->m_immediate;
1397 } else {
1398 base_and_offset.second += immediate_child->m_immediate;
1399 }
1400 return base_and_offset;
1401 }
1402 case Instruction::Operand::Type::Register: {
1403 const RegisterInfo *info =
1404 register_context.GetRegisterInfoByName(reg_name: operand.m_register.AsCString());
1405 if (!info) {
1406 return std::make_pair(x: nullptr, y: 0);
1407 }
1408 RegisterValue reg_value;
1409 if (!register_context.ReadRegister(reg_info: info, reg_value)) {
1410 return std::make_pair(x: nullptr, y: 0);
1411 }
1412 if (reg_value.GetAsUInt64() == value) {
1413 return std::make_pair(x: &operand, y: 0);
1414 } else {
1415 return std::make_pair(x: nullptr, y: 0);
1416 }
1417 }
1418 }
1419 return std::make_pair(x: nullptr, y: 0);
1420}
1421
1422std::pair<const Instruction::Operand *, int64_t>
1423GetBaseExplainingDereference(const Instruction::Operand &operand,
1424 RegisterContext &register_context,
1425 lldb::addr_t addr) {
1426 if (operand.m_type == Instruction::Operand::Type::Dereference) {
1427 return GetBaseExplainingValue(operand: operand.m_children[0], register_context,
1428 value: addr);
1429 }
1430 return std::make_pair(x: nullptr, y: 0);
1431}
1432} // namespace
1433
1434lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
1435 TargetSP target_sp = CalculateTarget();
1436
1437 const ArchSpec &target_arch = target_sp->GetArchitecture();
1438
1439 AddressRange pc_range;
1440 pc_range.GetBaseAddress() = GetFrameCodeAddress();
1441 pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
1442
1443 const char *plugin_name = nullptr;
1444 const char *flavor = nullptr;
1445 const char *cpu = nullptr;
1446 const char *features = nullptr;
1447 const bool force_live_memory = true;
1448
1449 DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1450 arch: target_arch, plugin_name, flavor, cpu, features, target&: *target_sp, disasm_ranges: pc_range,
1451 force_live_memory);
1452
1453 if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1454 return ValueObjectSP();
1455 }
1456
1457 InstructionSP instruction_sp =
1458 disassembler_sp->GetInstructionList().GetInstructionAtIndex(idx: 0);
1459
1460 llvm::SmallVector<Instruction::Operand, 3> operands;
1461
1462 if (!instruction_sp->ParseOperands(operands)) {
1463 return ValueObjectSP();
1464 }
1465
1466 RegisterContextSP register_context_sp = GetRegisterContext();
1467
1468 if (!register_context_sp) {
1469 return ValueObjectSP();
1470 }
1471
1472 for (const Instruction::Operand &operand : operands) {
1473 std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1474 GetBaseExplainingDereference(operand, register_context&: *register_context_sp, addr);
1475
1476 if (!base_and_offset.first) {
1477 continue;
1478 }
1479
1480 switch (base_and_offset.first->m_type) {
1481 case Instruction::Operand::Type::Immediate: {
1482 lldb_private::Address addr;
1483 if (target_sp->ResolveLoadAddress(load_addr: base_and_offset.first->m_immediate +
1484 base_and_offset.second,
1485 so_addr&: addr)) {
1486 auto c_type_system_or_err =
1487 target_sp->GetScratchTypeSystemForLanguage(language: eLanguageTypeC);
1488 if (auto err = c_type_system_or_err.takeError()) {
1489 LLDB_LOG_ERROR(GetLog(LLDBLog::Thread), std::move(err),
1490 "Unable to guess value for given address: {0}");
1491 return ValueObjectSP();
1492 } else {
1493 auto ts = *c_type_system_or_err;
1494 if (!ts)
1495 return {};
1496 CompilerType void_ptr_type =
1497 ts->GetBasicTypeFromAST(basic_type: lldb::BasicType::eBasicTypeChar)
1498 .GetPointerType();
1499 return ValueObjectMemory::Create(exe_scope: this, name: "", address: addr, ast_type: void_ptr_type);
1500 }
1501 } else {
1502 return ValueObjectSP();
1503 }
1504 break;
1505 }
1506 case Instruction::Operand::Type::Register: {
1507 return GuessValueForRegisterAndOffset(reg: base_and_offset.first->m_register,
1508 offset: base_and_offset.second);
1509 }
1510 default:
1511 return ValueObjectSP();
1512 }
1513 }
1514
1515 return ValueObjectSP();
1516}
1517
1518namespace {
1519ValueObjectSP GetValueForOffset(StackFrame &frame, ValueObjectSP &parent,
1520 int64_t offset) {
1521 if (offset < 0 ||
1522 uint64_t(offset) >=
1523 llvm::expectedToOptional(E: parent->GetByteSize()).value_or(u: 0)) {
1524 return ValueObjectSP();
1525 }
1526
1527 if (parent->IsPointerOrReferenceType()) {
1528 return parent;
1529 }
1530
1531 for (int ci = 0, ce = parent->GetNumChildrenIgnoringErrors(); ci != ce;
1532 ++ci) {
1533 ValueObjectSP child_sp = parent->GetChildAtIndex(idx: ci);
1534
1535 if (!child_sp) {
1536 return ValueObjectSP();
1537 }
1538
1539 int64_t child_offset = child_sp->GetByteOffset();
1540 int64_t child_size =
1541 llvm::expectedToOptional(E: child_sp->GetByteSize()).value_or(u: 0);
1542
1543 if (offset >= child_offset && offset < (child_offset + child_size)) {
1544 return GetValueForOffset(frame, parent&: child_sp, offset: offset - child_offset);
1545 }
1546 }
1547
1548 if (offset == 0) {
1549 return parent;
1550 } else {
1551 return ValueObjectSP();
1552 }
1553}
1554
1555ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
1556 ValueObjectSP &base,
1557 int64_t offset) {
1558 // base is a pointer to something
1559 // offset is the thing to add to the pointer We return the most sensible
1560 // ValueObject for the result of *(base+offset)
1561
1562 if (!base->IsPointerOrReferenceType()) {
1563 return ValueObjectSP();
1564 }
1565
1566 Status error;
1567 ValueObjectSP pointee = base->Dereference(error);
1568
1569 if (!pointee) {
1570 return ValueObjectSP();
1571 }
1572
1573 if (offset >= 0 &&
1574 uint64_t(offset) >=
1575 llvm::expectedToOptional(E: pointee->GetByteSize()).value_or(u: 0)) {
1576 uint64_t size =
1577 llvm::expectedToOptional(E: pointee->GetByteSize()).value_or(u: 1);
1578 int64_t index = offset / size;
1579 offset = offset % size;
1580 const bool can_create = true;
1581 pointee = base->GetSyntheticArrayMember(index, can_create);
1582 }
1583
1584 if (!pointee || error.Fail()) {
1585 return ValueObjectSP();
1586 }
1587
1588 return GetValueForOffset(frame, parent&: pointee, offset);
1589}
1590
1591/// Attempt to reconstruct the ValueObject for the address contained in a
1592/// given register plus an offset.
1593///
1594/// \param [in] frame
1595/// The current stack frame.
1596///
1597/// \param [in] reg
1598/// The register.
1599///
1600/// \param [in] offset
1601/// The offset from the register.
1602///
1603/// \param [in] disassembler
1604/// A disassembler containing instructions valid up to the current PC.
1605///
1606/// \param [in] variables
1607/// The variable list from the current frame,
1608///
1609/// \param [in] pc
1610/// The program counter for the instruction considered the 'user'.
1611///
1612/// \return
1613/// A string describing the base for the ExpressionPath. This could be a
1614/// variable, a register value, an argument, or a function return value.
1615/// The ValueObject if found. If valid, it has a valid ExpressionPath.
1616lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
1617 int64_t offset, Disassembler &disassembler,
1618 VariableList &variables, const Address &pc) {
1619 // Example of operation for Intel:
1620 //
1621 // +14: movq -0x8(%rbp), %rdi
1622 // +18: movq 0x8(%rdi), %rdi
1623 // +22: addl 0x4(%rdi), %eax
1624 //
1625 // f, a pointer to a struct, is known to be at -0x8(%rbp).
1626 //
1627 // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at
1628 // +18 that assigns to rdi, and calls itself recursively for that dereference
1629 // DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
1630 // +14 that assigns to rdi, and calls itself recursively for that
1631 // dereference
1632 // DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the
1633 // variable list.
1634 // Returns a ValueObject for f. (That's what was stored at rbp-8 at +14)
1635 // Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
1636 // at +18)
1637 // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
1638 // rdi+4 at +22)
1639
1640 // First, check the variable list to see if anything is at the specified
1641 // location.
1642
1643 using namespace OperandMatchers;
1644
1645 const RegisterInfo *reg_info =
1646 frame.GetRegisterContext()->GetRegisterInfoByName(reg_name: reg.AsCString());
1647 if (!reg_info) {
1648 return ValueObjectSP();
1649 }
1650
1651 Instruction::Operand op =
1652 offset ? Instruction::Operand::BuildDereference(
1653 ref: Instruction::Operand::BuildSum(
1654 lhs: Instruction::Operand::BuildRegister(r&: reg),
1655 rhs: Instruction::Operand::BuildImmediate(imm: offset)))
1656 : Instruction::Operand::BuildDereference(
1657 ref: Instruction::Operand::BuildRegister(r&: reg));
1658
1659 for (VariableSP var_sp : variables) {
1660 if (var_sp->LocationExpressionList().MatchesOperand(frame, operand: op))
1661 return frame.GetValueObjectForFrameVariable(variable_sp: var_sp, use_dynamic: eNoDynamicValues);
1662 }
1663
1664 const uint32_t current_inst =
1665 disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(addr: pc);
1666 if (current_inst == UINT32_MAX) {
1667 return ValueObjectSP();
1668 }
1669
1670 for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {
1671 // This is not an exact algorithm, and it sacrifices accuracy for
1672 // generality. Recognizing "mov" and "ld" instructions –– and which
1673 // are their source and destination operands -- is something the
1674 // disassembler should do for us.
1675 InstructionSP instruction_sp =
1676 disassembler.GetInstructionList().GetInstructionAtIndex(idx: ii);
1677
1678 if (instruction_sp->IsCall()) {
1679 ABISP abi_sp = frame.CalculateProcess()->GetABI();
1680 if (!abi_sp) {
1681 continue;
1682 }
1683
1684 const char *return_register_name;
1685 if (!abi_sp->GetPointerReturnRegister(name&: return_register_name)) {
1686 continue;
1687 }
1688
1689 const RegisterInfo *return_register_info =
1690 frame.GetRegisterContext()->GetRegisterInfoByName(
1691 reg_name: return_register_name);
1692 if (!return_register_info) {
1693 continue;
1694 }
1695
1696 int64_t offset = 0;
1697
1698 if (!MatchUnaryOp(base: MatchOpType(type: Instruction::Operand::Type::Dereference),
1699 child: MatchRegOp(info: *return_register_info))(op) &&
1700 !MatchUnaryOp(
1701 base: MatchOpType(type: Instruction::Operand::Type::Dereference),
1702 child: MatchBinaryOp(base: MatchOpType(type: Instruction::Operand::Type::Sum),
1703 left: MatchRegOp(info: *return_register_info),
1704 right: FetchImmOp(imm&: offset)))(op)) {
1705 continue;
1706 }
1707
1708 llvm::SmallVector<Instruction::Operand, 1> operands;
1709 if (!instruction_sp->ParseOperands(operands) || operands.size() != 1) {
1710 continue;
1711 }
1712
1713 switch (operands[0].m_type) {
1714 default:
1715 break;
1716 case Instruction::Operand::Type::Immediate: {
1717 SymbolContext sc;
1718 if (!pc.GetModule())
1719 break;
1720 Address address(operands[0].m_immediate,
1721 pc.GetModule()->GetSectionList());
1722 if (!address.IsValid())
1723 break;
1724 frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(
1725 so_addr: address, resolve_scope: eSymbolContextFunction, sc);
1726 if (!sc.function) {
1727 break;
1728 }
1729 CompilerType function_type = sc.function->GetCompilerType();
1730 if (!function_type.IsFunctionType()) {
1731 break;
1732 }
1733 CompilerType return_type = function_type.GetFunctionReturnType();
1734 RegisterValue return_value;
1735 if (!frame.GetRegisterContext()->ReadRegister(reg_info: return_register_info,
1736 reg_value&: return_value)) {
1737 break;
1738 }
1739 std::string name_str(
1740 sc.function->GetName().AsCString(value_if_empty: "<unknown function>"));
1741 name_str.append(s: "()");
1742 Address return_value_address(return_value.GetAsUInt64());
1743 ValueObjectSP return_value_sp = ValueObjectMemory::Create(
1744 exe_scope: &frame, name: name_str, address: return_value_address, ast_type: return_type);
1745 return GetValueForDereferincingOffset(frame, base&: return_value_sp, offset);
1746 }
1747 }
1748
1749 continue;
1750 }
1751
1752 llvm::SmallVector<Instruction::Operand, 2> operands;
1753 if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
1754 continue;
1755 }
1756
1757 Instruction::Operand *origin_operand = nullptr;
1758 auto clobbered_reg_matcher = [reg_info](const Instruction::Operand &op) {
1759 return MatchRegOp(info: *reg_info)(op) && op.m_clobbered;
1760 };
1761
1762 if (clobbered_reg_matcher(operands[0])) {
1763 origin_operand = &operands[1];
1764 }
1765 else if (clobbered_reg_matcher(operands[1])) {
1766 origin_operand = &operands[0];
1767 }
1768 else {
1769 continue;
1770 }
1771
1772 // We have an origin operand. Can we track its value down?
1773 ValueObjectSP source_path;
1774 ConstString origin_register;
1775 int64_t origin_offset = 0;
1776
1777 if (FetchRegOp(reg&: origin_register)(*origin_operand)) {
1778 source_path = DoGuessValueAt(frame, reg: origin_register, offset: 0, disassembler,
1779 variables, pc: instruction_sp->GetAddress());
1780 } else if (MatchUnaryOp(
1781 base: MatchOpType(type: Instruction::Operand::Type::Dereference),
1782 child: FetchRegOp(reg&: origin_register))(*origin_operand) ||
1783 MatchUnaryOp(
1784 base: MatchOpType(type: Instruction::Operand::Type::Dereference),
1785 child: MatchBinaryOp(base: MatchOpType(type: Instruction::Operand::Type::Sum),
1786 left: FetchRegOp(reg&: origin_register),
1787 right: FetchImmOp(imm&: origin_offset)))(*origin_operand)) {
1788 source_path =
1789 DoGuessValueAt(frame, reg: origin_register, offset: origin_offset, disassembler,
1790 variables, pc: instruction_sp->GetAddress());
1791 if (!source_path) {
1792 continue;
1793 }
1794 source_path =
1795 GetValueForDereferincingOffset(frame, base&: source_path, offset);
1796 }
1797
1798 if (source_path) {
1799 return source_path;
1800 }
1801 }
1802
1803 return ValueObjectSP();
1804}
1805}
1806
1807lldb::ValueObjectSP StackFrame::GuessValueForRegisterAndOffset(ConstString reg,
1808 int64_t offset) {
1809 TargetSP target_sp = CalculateTarget();
1810
1811 const ArchSpec &target_arch = target_sp->GetArchitecture();
1812
1813 Block *frame_block = GetFrameBlock();
1814
1815 if (!frame_block) {
1816 return ValueObjectSP();
1817 }
1818
1819 Function *function = frame_block->CalculateSymbolContextFunction();
1820 if (!function) {
1821 return ValueObjectSP();
1822 }
1823
1824 AddressRange unused_range;
1825 if (!function->GetRangeContainingLoadAddress(
1826 load_addr: GetFrameCodeAddress().GetLoadAddress(target: target_sp.get()), target&: *target_sp,
1827 range&: unused_range))
1828 return ValueObjectSP();
1829
1830 const char *plugin_name = nullptr;
1831 const char *flavor = nullptr;
1832 const char *cpu = nullptr;
1833 const char *features = nullptr;
1834 const bool force_live_memory = true;
1835 DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1836 arch: target_arch, plugin_name, flavor, cpu, features, target&: *target_sp,
1837 disasm_ranges: function->GetAddressRanges(), force_live_memory);
1838
1839 if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1840 return ValueObjectSP();
1841 }
1842
1843 const bool get_file_globals = false;
1844 VariableList *variables = GetVariableList(get_file_globals, error_ptr: nullptr);
1845
1846 if (!variables) {
1847 return ValueObjectSP();
1848 }
1849
1850 return DoGuessValueAt(frame&: *this, reg, offset, disassembler&: *disassembler_sp, variables&: *variables,
1851 pc: GetFrameCodeAddress());
1852}
1853
1854lldb::ValueObjectSP StackFrame::FindVariable(ConstString name) {
1855 ValueObjectSP value_sp;
1856
1857 if (!name)
1858 return value_sp;
1859
1860 TargetSP target_sp = CalculateTarget();
1861 ProcessSP process_sp = CalculateProcess();
1862
1863 if (!target_sp && !process_sp)
1864 return value_sp;
1865
1866 VariableList variable_list;
1867 VariableSP var_sp;
1868 SymbolContext sc(GetSymbolContext(resolve_scope: eSymbolContextBlock));
1869
1870 if (sc.block) {
1871 const bool can_create = true;
1872 const bool get_parent_variables = true;
1873 const bool stop_if_block_is_inlined_function = true;
1874
1875 if (sc.block->AppendVariables(
1876 can_create, get_parent_variables, stop_if_block_is_inlined_function,
1877 filter: [this](Variable *v) { return v->IsInScope(frame: this); },
1878 variable_list: &variable_list)) {
1879 var_sp = variable_list.FindVariable(name);
1880 }
1881
1882 if (var_sp)
1883 value_sp = GetValueObjectForFrameVariable(variable_sp: var_sp, use_dynamic: eNoDynamicValues);
1884 }
1885
1886 return value_sp;
1887}
1888
1889TargetSP StackFrame::CalculateTarget() {
1890 TargetSP target_sp;
1891 ThreadSP thread_sp(GetThread());
1892 if (thread_sp) {
1893 ProcessSP process_sp(thread_sp->CalculateProcess());
1894 if (process_sp)
1895 target_sp = process_sp->CalculateTarget();
1896 }
1897 return target_sp;
1898}
1899
1900ProcessSP StackFrame::CalculateProcess() {
1901 ProcessSP process_sp;
1902 ThreadSP thread_sp(GetThread());
1903 if (thread_sp)
1904 process_sp = thread_sp->CalculateProcess();
1905 return process_sp;
1906}
1907
1908ThreadSP StackFrame::CalculateThread() { return GetThread(); }
1909
1910StackFrameSP StackFrame::CalculateStackFrame() { return shared_from_this(); }
1911
1912void StackFrame::CalculateExecutionContext(ExecutionContext &exe_ctx) {
1913 exe_ctx.SetContext(shared_from_this());
1914}
1915
1916bool StackFrame::DumpUsingFormat(Stream &strm,
1917 const FormatEntity::Entry *format,
1918 llvm::StringRef frame_marker) {
1919 GetSymbolContext(resolve_scope: eSymbolContextEverything);
1920 ExecutionContext exe_ctx(shared_from_this());
1921 StreamString s;
1922 s.PutCString(cstr: frame_marker);
1923
1924 if (format && FormatEntity::Format(entry: *format, s, sc: &m_sc, exe_ctx: &exe_ctx, addr: nullptr,
1925 valobj: nullptr, function_changed: false, initial_function: false)) {
1926 strm.PutCString(cstr: s.GetString());
1927 return true;
1928 }
1929 return false;
1930}
1931
1932void StackFrame::DumpUsingSettingsFormat(Stream *strm, bool show_unique,
1933 const char *frame_marker) {
1934 if (strm == nullptr)
1935 return;
1936
1937 ExecutionContext exe_ctx(shared_from_this());
1938
1939 const FormatEntity::Entry *frame_format = nullptr;
1940 FormatEntity::Entry format_entry;
1941 Target *target = exe_ctx.GetTargetPtr();
1942 if (target) {
1943 if (show_unique) {
1944 format_entry = target->GetDebugger().GetFrameFormatUnique();
1945 frame_format = &format_entry;
1946 } else {
1947 format_entry = target->GetDebugger().GetFrameFormat();
1948 frame_format = &format_entry;
1949 }
1950 }
1951 if (!DumpUsingFormat(strm&: *strm, format: frame_format, frame_marker)) {
1952 Dump(strm, show_frame_index: true, show_fullpaths: false);
1953 strm->EOL();
1954 }
1955}
1956
1957void StackFrame::Dump(Stream *strm, bool show_frame_index,
1958 bool show_fullpaths) {
1959 if (strm == nullptr)
1960 return;
1961
1962 if (show_frame_index)
1963 strm->Printf(format: "frame #%u: ", m_frame_index);
1964 ExecutionContext exe_ctx(shared_from_this());
1965 Target *target = exe_ctx.GetTargetPtr();
1966 strm->Printf(format: "0x%0*" PRIx64 " ",
1967 target ? (target->GetArchitecture().GetAddressByteSize() * 2)
1968 : 16,
1969 GetFrameCodeAddress().GetLoadAddress(target));
1970 GetSymbolContext(resolve_scope: eSymbolContextEverything);
1971 const bool show_module = true;
1972 const bool show_inline = true;
1973 const bool show_function_arguments = true;
1974 const bool show_function_name = true;
1975 m_sc.DumpStopContext(s: strm, exe_scope: exe_ctx.GetBestExecutionContextScope(),
1976 so_addr: GetFrameCodeAddress(), show_fullpaths, show_module,
1977 show_inlined_frames: show_inline, show_function_arguments,
1978 show_function_name);
1979}
1980
1981void StackFrame::UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame) {
1982 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1983 assert(GetStackID() ==
1984 prev_frame.GetStackID()); // TODO: remove this after some testing
1985 m_variable_list_sp = prev_frame.m_variable_list_sp;
1986 m_variable_list_value_objects.Swap(value_object_list&: prev_frame.m_variable_list_value_objects);
1987 if (!m_disassembly.GetString().empty()) {
1988 m_disassembly.Clear();
1989 m_disassembly.PutCString(cstr: prev_frame.m_disassembly.GetString());
1990 }
1991}
1992
1993void StackFrame::UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame) {
1994 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1995 assert(GetStackID() ==
1996 curr_frame.GetStackID()); // TODO: remove this after some testing
1997 m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value
1998 assert(GetThread() == curr_frame.GetThread());
1999 m_frame_index = curr_frame.m_frame_index;
2000 m_concrete_frame_index = curr_frame.m_concrete_frame_index;
2001 m_reg_context_sp = curr_frame.m_reg_context_sp;
2002 m_frame_code_addr = curr_frame.m_frame_code_addr;
2003 m_behaves_like_zeroth_frame = curr_frame.m_behaves_like_zeroth_frame;
2004 assert(!m_sc.target_sp || !curr_frame.m_sc.target_sp ||
2005 m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
2006 assert(!m_sc.module_sp || !curr_frame.m_sc.module_sp ||
2007 m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
2008 assert(m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr ||
2009 m_sc.comp_unit == curr_frame.m_sc.comp_unit);
2010 assert(m_sc.function == nullptr || curr_frame.m_sc.function == nullptr ||
2011 m_sc.function == curr_frame.m_sc.function);
2012 m_sc = curr_frame.m_sc;
2013 m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
2014 m_flags.Set(m_sc.GetResolvedMask());
2015 m_frame_base.Clear();
2016 m_frame_base_error.Clear();
2017}
2018
2019bool StackFrame::HasCachedData() const {
2020 if (m_variable_list_sp)
2021 return true;
2022 if (m_variable_list_value_objects.GetSize() > 0)
2023 return true;
2024 if (!m_disassembly.GetString().empty())
2025 return true;
2026 return false;
2027}
2028
2029bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
2030 bool show_unique, const char *frame_marker) {
2031 if (show_frame_info) {
2032 strm.Indent();
2033 DumpUsingSettingsFormat(strm: &strm, show_unique, frame_marker);
2034 }
2035
2036 if (show_source) {
2037 ExecutionContext exe_ctx(shared_from_this());
2038 bool have_source = false, have_debuginfo = false;
2039 lldb::StopDisassemblyType disasm_display = lldb::eStopDisassemblyTypeNever;
2040 Target *target = exe_ctx.GetTargetPtr();
2041 if (target) {
2042 Debugger &debugger = target->GetDebugger();
2043 const uint32_t source_lines_before =
2044 debugger.GetStopSourceLineCount(before: true);
2045 const uint32_t source_lines_after =
2046 debugger.GetStopSourceLineCount(before: false);
2047 disasm_display = debugger.GetStopDisassemblyDisplay();
2048
2049 GetSymbolContext(resolve_scope: eSymbolContextCompUnit | eSymbolContextLineEntry);
2050 if (m_sc.comp_unit && m_sc.line_entry.IsValid()) {
2051 have_debuginfo = true;
2052 if (source_lines_before > 0 || source_lines_after > 0) {
2053 SupportFileSP source_file_sp = m_sc.line_entry.file_sp;
2054 uint32_t start_line = m_sc.line_entry.line;
2055 if (!start_line && m_sc.function) {
2056 m_sc.function->GetStartLineSourceInfo(source_file_sp, line_no&: start_line);
2057 }
2058
2059 size_t num_lines =
2060 target->GetSourceManager().DisplaySourceLinesWithLineNumbers(
2061 support_file_sp: source_file_sp, line: start_line, column: m_sc.line_entry.column,
2062 context_before: source_lines_before, context_after: source_lines_after, current_line_cstr: "->", s: &strm);
2063 if (num_lines != 0)
2064 have_source = true;
2065 // TODO: Give here a one time warning if source file is missing.
2066 if (!m_sc.line_entry.line)
2067 strm << "note: This address is not associated with a specific line "
2068 "of code. This may be due to compiler optimizations.\n";
2069 }
2070 }
2071 switch (disasm_display) {
2072 case lldb::eStopDisassemblyTypeNever:
2073 break;
2074
2075 case lldb::eStopDisassemblyTypeNoDebugInfo:
2076 if (have_debuginfo)
2077 break;
2078 [[fallthrough]];
2079
2080 case lldb::eStopDisassemblyTypeNoSource:
2081 if (have_source)
2082 break;
2083 [[fallthrough]];
2084
2085 case lldb::eStopDisassemblyTypeAlways:
2086 if (target) {
2087 const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
2088 if (disasm_lines > 0) {
2089 const ArchSpec &target_arch = target->GetArchitecture();
2090 const char *plugin_name = nullptr;
2091 const char *flavor = nullptr;
2092 const bool mixed_source_and_assembly = false;
2093 Disassembler::Disassemble(
2094 debugger&: target->GetDebugger(), arch: target_arch, plugin_name, flavor,
2095 cpu: target->GetDisassemblyCPU(), features: target->GetDisassemblyFeatures(),
2096 exe_ctx, start: GetFrameCodeAddress(),
2097 limit: {.kind: Disassembler::Limit::Instructions, .value: disasm_lines},
2098 mixed_source_and_assembly, num_mixed_context_lines: 0,
2099 options: Disassembler::eOptionMarkPCAddress, strm);
2100 }
2101 }
2102 break;
2103 }
2104 }
2105 }
2106 return true;
2107}
2108
2109RecognizedStackFrameSP StackFrame::GetRecognizedFrame() {
2110 auto process = GetThread()->GetProcess();
2111 if (!process)
2112 return {};
2113 // If recognizer list has been modified, discard cache.
2114 auto &manager = process->GetTarget().GetFrameRecognizerManager();
2115 auto new_generation = manager.GetGeneration();
2116 if (m_frame_recognizer_generation != new_generation)
2117 m_recognized_frame_sp.reset();
2118 m_frame_recognizer_generation = new_generation;
2119 if (!m_recognized_frame_sp.has_value())
2120 m_recognized_frame_sp = manager.RecognizeFrame(frame: CalculateStackFrame());
2121 return m_recognized_frame_sp.value();
2122}
2123

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of lldb/source/Target/StackFrame.cpp