Bug Summary

File:lldb/source/Target/StackFrame.cpp
Warning:line 564, column 11
Value stored to 'separator_idx' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

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