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