1 //===-- StackFrame.cpp ------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 // Other libraries and framework includes
14 #include "lldb/Target/StackFrame.h"
15 #include "lldb/Core/Debugger.h"
16 #include "lldb/Core/Disassembler.h"
17 #include "lldb/Core/FormatEntity.h"
18 #include "lldb/Core/Mangled.h"
19 #include "lldb/Core/Module.h"
20 #include "lldb/Core/RegisterValue.h"
21 #include "lldb/Core/Value.h"
22 #include "lldb/Core/ValueObjectConstResult.h"
23 #include "lldb/Core/ValueObjectMemory.h"
24 #include "lldb/Core/ValueObjectVariable.h"
25 #include "lldb/Symbol/CompileUnit.h"
26 #include "lldb/Symbol/Function.h"
27 #include "lldb/Symbol/Symbol.h"
28 #include "lldb/Symbol/SymbolContextScope.h"
29 #include "lldb/Symbol/Type.h"
30 #include "lldb/Symbol/VariableList.h"
31 #include "lldb/Target/ABI.h"
32 #include "lldb/Target/ExecutionContext.h"
33 #include "lldb/Target/Process.h"
34 #include "lldb/Target/RegisterContext.h"
35 #include "lldb/Target/Target.h"
36 #include "lldb/Target/Thread.h"
39 using namespace lldb_private;
41 // The first bits in the flags are reserved for the SymbolContext::Scope bits
42 // so we know if we have tried to look up information in our internal symbol
43 // context (m_sc) already.
44 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
45 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
46 #define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
47 #define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1)
48 #define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1)
50 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
51 user_id_t unwind_frame_index, addr_t cfa,
52 bool cfa_is_valid, addr_t pc, uint32_t stop_id,
53 bool stop_id_is_valid, bool is_history_frame,
54 const SymbolContext *sc_ptr)
55 : m_thread_wp(thread_sp), m_frame_index(frame_idx),
56 m_concrete_frame_index(unwind_frame_index), m_reg_context_sp(),
57 m_id(pc, cfa, nullptr), m_frame_code_addr(pc), m_sc(), m_flags(),
58 m_frame_base(), m_frame_base_error(), m_cfa_is_valid(cfa_is_valid),
59 m_stop_id(stop_id), m_stop_id_is_valid(stop_id_is_valid),
60 m_is_history_frame(is_history_frame), m_variable_list_sp(),
61 m_variable_list_value_objects(), m_disassembly(), m_mutex() {
62 // If we don't have a CFA value, use the frame index for our StackID so that
64 // functions properly aren't confused with one another on a history stack.
65 if (m_is_history_frame && !m_cfa_is_valid) {
66 m_id.SetCFA(m_frame_index);
69 if (sc_ptr != nullptr) {
71 m_flags.Set(m_sc.GetResolvedMask());
75 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
76 user_id_t unwind_frame_index,
77 const RegisterContextSP ®_context_sp, addr_t cfa,
78 addr_t pc, const SymbolContext *sc_ptr)
79 : m_thread_wp(thread_sp), m_frame_index(frame_idx),
80 m_concrete_frame_index(unwind_frame_index),
81 m_reg_context_sp(reg_context_sp), m_id(pc, cfa, nullptr),
82 m_frame_code_addr(pc), m_sc(), m_flags(), m_frame_base(),
83 m_frame_base_error(), m_cfa_is_valid(true), m_stop_id(0),
84 m_stop_id_is_valid(false), m_is_history_frame(false),
85 m_variable_list_sp(), m_variable_list_value_objects(), m_disassembly(),
87 if (sc_ptr != nullptr) {
89 m_flags.Set(m_sc.GetResolvedMask());
92 if (reg_context_sp && !m_sc.target_sp) {
93 m_sc.target_sp = reg_context_sp->CalculateTarget();
95 m_flags.Set(eSymbolContextTarget);
99 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
100 user_id_t unwind_frame_index,
101 const RegisterContextSP ®_context_sp, addr_t cfa,
102 const Address &pc_addr, const SymbolContext *sc_ptr)
103 : m_thread_wp(thread_sp), m_frame_index(frame_idx),
104 m_concrete_frame_index(unwind_frame_index),
105 m_reg_context_sp(reg_context_sp),
106 m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa,
108 m_frame_code_addr(pc_addr), m_sc(), m_flags(), m_frame_base(),
109 m_frame_base_error(), m_cfa_is_valid(true), m_stop_id(0),
110 m_stop_id_is_valid(false), m_is_history_frame(false),
111 m_variable_list_sp(), m_variable_list_value_objects(), m_disassembly(),
113 if (sc_ptr != nullptr) {
115 m_flags.Set(m_sc.GetResolvedMask());
118 if (!m_sc.target_sp && reg_context_sp) {
119 m_sc.target_sp = reg_context_sp->CalculateTarget();
121 m_flags.Set(eSymbolContextTarget);
124 ModuleSP pc_module_sp(pc_addr.GetModule());
125 if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp) {
127 m_sc.module_sp = pc_module_sp;
128 m_flags.Set(eSymbolContextModule);
130 m_sc.module_sp.reset();
135 StackFrame::~StackFrame() = default;
137 StackID &StackFrame::GetStackID() {
138 std::lock_guard<std::recursive_mutex> guard(m_mutex);
139 // Make sure we have resolved the StackID object's symbol context scope if
140 // we already haven't looked it up.
142 if (m_flags.IsClear(RESOLVED_FRAME_ID_SYMBOL_SCOPE)) {
143 if (m_id.GetSymbolContextScope()) {
144 // We already have a symbol context scope, we just don't have our
146 m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
148 // Calculate the frame block and use this for the stack ID symbol
149 // context scope if we have one.
150 SymbolContextScope *scope = GetFrameBlock();
151 if (scope == nullptr) {
152 // We don't have a block, so use the symbol
153 if (m_flags.IsClear(eSymbolContextSymbol))
154 GetSymbolContext(eSymbolContextSymbol);
156 // It is ok if m_sc.symbol is nullptr here
159 // Set the symbol context scope (the accessor will set the
160 // RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags).
161 SetSymbolContextScope(scope);
167 uint32_t StackFrame::GetFrameIndex() const {
168 ThreadSP thread_sp = GetThread();
170 return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
173 return m_frame_index;
176 void StackFrame::SetSymbolContextScope(SymbolContextScope *symbol_scope) {
177 std::lock_guard<std::recursive_mutex> guard(m_mutex);
178 m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
179 m_id.SetSymbolContextScope(symbol_scope);
182 const Address &StackFrame::GetFrameCodeAddress() {
183 std::lock_guard<std::recursive_mutex> guard(m_mutex);
184 if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) &&
185 !m_frame_code_addr.IsSectionOffset()) {
186 m_flags.Set(RESOLVED_FRAME_CODE_ADDR);
188 // Resolve the PC into a temporary address because if ResolveLoadAddress
189 // fails to resolve the address, it will clear the address object...
190 ThreadSP thread_sp(GetThread());
192 TargetSP target_sp(thread_sp->CalculateTarget());
194 const bool allow_section_end = true;
195 if (m_frame_code_addr.SetOpcodeLoadAddress(
196 m_frame_code_addr.GetOffset(), target_sp.get(),
197 eAddressClassCode, allow_section_end)) {
198 ModuleSP module_sp(m_frame_code_addr.GetModule());
200 m_sc.module_sp = module_sp;
201 m_flags.Set(eSymbolContextModule);
207 return m_frame_code_addr;
210 bool StackFrame::ChangePC(addr_t pc) {
211 std::lock_guard<std::recursive_mutex> guard(m_mutex);
212 // We can't change the pc value of a history stack frame - it is immutable.
213 if (m_is_history_frame)
215 m_frame_code_addr.SetRawAddress(pc);
218 ThreadSP thread_sp(GetThread());
220 thread_sp->ClearStackFrames();
224 const char *StackFrame::Disassemble() {
225 std::lock_guard<std::recursive_mutex> guard(m_mutex);
226 if (m_disassembly.Empty()) {
227 ExecutionContext exe_ctx(shared_from_this());
228 Target *target = exe_ctx.GetTargetPtr();
230 const char *plugin_name = nullptr;
231 const char *flavor = nullptr;
232 Disassembler::Disassemble(target->GetDebugger(),
233 target->GetArchitecture(), plugin_name, flavor,
234 exe_ctx, 0, false, 0, 0, m_disassembly);
236 if (m_disassembly.Empty())
240 return m_disassembly.GetData();
243 Block *StackFrame::GetFrameBlock() {
244 if (m_sc.block == nullptr && m_flags.IsClear(eSymbolContextBlock))
245 GetSymbolContext(eSymbolContextBlock);
248 Block *inline_block = m_sc.block->GetContainingInlinedBlock();
250 // Use the block with the inlined function info
251 // as the frame block we want this frame to have only the variables
252 // for the inlined function and its non-inlined block child blocks.
255 // This block is not contained within any inlined function blocks
256 // with so we want to use the top most function block.
257 return &m_sc.function->GetBlock(false);
263 //----------------------------------------------------------------------
264 // Get the symbol context if we already haven't done so by resolving the
265 // PC address as much as possible. This way when we pass around a
266 // StackFrame object, everyone will have as much information as
267 // possible and no one will ever have to look things up manually.
268 //----------------------------------------------------------------------
269 const SymbolContext &StackFrame::GetSymbolContext(uint32_t resolve_scope) {
270 std::lock_guard<std::recursive_mutex> guard(m_mutex);
271 // Copy our internal symbol context into "sc".
272 if ((m_flags.Get() & resolve_scope) != resolve_scope) {
273 uint32_t resolved = 0;
275 // If the target was requested add that:
276 if (!m_sc.target_sp) {
277 m_sc.target_sp = CalculateTarget();
279 resolved |= eSymbolContextTarget;
282 // Resolve our PC to section offset if we haven't already done so
283 // and if we don't have a module. The resolved address section will
284 // contain the module to which it belongs
285 if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
286 GetFrameCodeAddress();
288 // If this is not frame zero, then we need to subtract 1 from the PC
289 // value when doing address lookups since the PC will be on the
290 // instruction following the function call instruction...
292 Address lookup_addr(GetFrameCodeAddress());
293 if (m_frame_index > 0 && lookup_addr.IsValid()) {
294 addr_t offset = lookup_addr.GetOffset();
296 lookup_addr.SetOffset(offset - 1);
299 // lookup_addr is the start of a section. We need
300 // do the math on the actual load address and re-compute
301 // the section. We're working with a 'noreturn' function
302 // at the end of a section.
303 ThreadSP thread_sp(GetThread());
305 TargetSP target_sp(thread_sp->CalculateTarget());
307 addr_t addr_minus_one =
308 lookup_addr.GetLoadAddress(target_sp.get()) - 1;
309 lookup_addr.SetLoadAddress(addr_minus_one, target_sp.get());
311 lookup_addr.SetOffset(offset - 1);
317 if (m_sc.module_sp) {
318 // We have something in our stack frame symbol context, lets check
319 // if we haven't already tried to lookup one of those things. If we
320 // haven't then we will do the query.
322 uint32_t actual_resolve_scope = 0;
324 if (resolve_scope & eSymbolContextCompUnit) {
325 if (m_flags.IsClear(eSymbolContextCompUnit)) {
327 resolved |= eSymbolContextCompUnit;
329 actual_resolve_scope |= eSymbolContextCompUnit;
333 if (resolve_scope & eSymbolContextFunction) {
334 if (m_flags.IsClear(eSymbolContextFunction)) {
336 resolved |= eSymbolContextFunction;
338 actual_resolve_scope |= eSymbolContextFunction;
342 if (resolve_scope & eSymbolContextBlock) {
343 if (m_flags.IsClear(eSymbolContextBlock)) {
345 resolved |= eSymbolContextBlock;
347 actual_resolve_scope |= eSymbolContextBlock;
351 if (resolve_scope & eSymbolContextSymbol) {
352 if (m_flags.IsClear(eSymbolContextSymbol)) {
354 resolved |= eSymbolContextSymbol;
356 actual_resolve_scope |= eSymbolContextSymbol;
360 if (resolve_scope & eSymbolContextLineEntry) {
361 if (m_flags.IsClear(eSymbolContextLineEntry)) {
362 if (m_sc.line_entry.IsValid())
363 resolved |= eSymbolContextLineEntry;
365 actual_resolve_scope |= eSymbolContextLineEntry;
369 if (actual_resolve_scope) {
370 // We might be resolving less information than what is already
371 // in our current symbol context so resolve into a temporary
372 // symbol context "sc" so we don't clear out data we have
373 // already found in "m_sc"
375 // Set flags that indicate what we have tried to resolve
376 resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
377 lookup_addr, actual_resolve_scope, sc);
378 // Only replace what we didn't already have as we may have
379 // information for an inlined function scope that won't match
380 // what a standard lookup by address would match
381 if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
382 m_sc.comp_unit = sc.comp_unit;
383 if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
384 m_sc.function = sc.function;
385 if ((resolved & eSymbolContextBlock) && m_sc.block == nullptr)
386 m_sc.block = sc.block;
387 if ((resolved & eSymbolContextSymbol) && m_sc.symbol == nullptr)
388 m_sc.symbol = sc.symbol;
389 if ((resolved & eSymbolContextLineEntry) &&
390 !m_sc.line_entry.IsValid()) {
391 m_sc.line_entry = sc.line_entry;
392 m_sc.line_entry.ApplyFileMappings(m_sc.target_sp);
396 // If we don't have a module, then we can't have the compile unit,
397 // function, block, line entry or symbol, so we can safely call
398 // ResolveSymbolContextForAddress with our symbol context member m_sc.
399 if (m_sc.target_sp) {
400 resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
401 lookup_addr, resolve_scope, m_sc);
405 // Update our internal flags so we remember what we have tried to locate so
406 // we don't have to keep trying when more calls to this function are made.
407 // We might have dug up more information that was requested (for example
408 // if we were asked to only get the block, we will have gotten the
409 // compile unit, and function) so set any additional bits that we resolved
410 m_flags.Set(resolve_scope | resolved);
413 // Return the symbol context with everything that was possible to resolve
418 VariableList *StackFrame::GetVariableList(bool get_file_globals) {
419 std::lock_guard<std::recursive_mutex> guard(m_mutex);
420 if (m_flags.IsClear(RESOLVED_VARIABLES)) {
421 m_flags.Set(RESOLVED_VARIABLES);
423 Block *frame_block = GetFrameBlock();
426 const bool get_child_variables = true;
427 const bool can_create = true;
428 const bool stop_if_child_block_is_inlined_function = true;
429 m_variable_list_sp.reset(new VariableList());
430 frame_block->AppendBlockVariables(can_create, get_child_variables,
431 stop_if_child_block_is_inlined_function,
432 [](Variable *v) { return true; },
433 m_variable_list_sp.get());
437 if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
438 m_flags.Set(RESOLVED_GLOBAL_VARIABLES);
440 if (m_flags.IsClear(eSymbolContextCompUnit))
441 GetSymbolContext(eSymbolContextCompUnit);
443 if (m_sc.comp_unit) {
444 VariableListSP global_variable_list_sp(
445 m_sc.comp_unit->GetVariableList(true));
446 if (m_variable_list_sp)
447 m_variable_list_sp->AddVariables(global_variable_list_sp.get());
449 m_variable_list_sp = global_variable_list_sp;
453 return m_variable_list_sp.get();
457 StackFrame::GetInScopeVariableList(bool get_file_globals,
458 bool must_have_valid_location) {
459 std::lock_guard<std::recursive_mutex> guard(m_mutex);
460 // We can't fetch variable information for a history stack frame.
461 if (m_is_history_frame)
462 return VariableListSP();
464 VariableListSP var_list_sp(new VariableList);
465 GetSymbolContext(eSymbolContextCompUnit | eSymbolContextBlock);
468 const bool can_create = true;
469 const bool get_parent_variables = true;
470 const bool stop_if_block_is_inlined_function = true;
471 m_sc.block->AppendVariables(
472 can_create, get_parent_variables, stop_if_block_is_inlined_function,
473 [this, must_have_valid_location](Variable *v) {
474 return v->IsInScope(this) && (!must_have_valid_location ||
475 v->LocationIsValidForFrame(this));
480 if (m_sc.comp_unit && get_file_globals) {
481 VariableListSP global_variable_list_sp(
482 m_sc.comp_unit->GetVariableList(true));
483 if (global_variable_list_sp)
484 var_list_sp->AddVariables(global_variable_list_sp.get());
490 ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
491 llvm::StringRef var_expr, DynamicValueType use_dynamic, uint32_t options,
492 VariableSP &var_sp, Status &error) {
493 llvm::StringRef original_var_expr = var_expr;
494 // We can't fetch variable information for a history stack frame.
495 if (m_is_history_frame)
496 return ValueObjectSP();
498 if (var_expr.empty()) {
499 error.SetErrorStringWithFormat("invalid variable path '%s'",
500 var_expr.str().c_str());
501 return ValueObjectSP();
504 const bool check_ptr_vs_member =
505 (options & eExpressionPathOptionCheckPtrVsMember) != 0;
506 const bool no_fragile_ivar =
507 (options & eExpressionPathOptionsNoFragileObjcIvar) != 0;
508 const bool no_synth_child =
509 (options & eExpressionPathOptionsNoSyntheticChildren) != 0;
510 // const bool no_synth_array = (options &
511 // eExpressionPathOptionsNoSyntheticArrayRange) != 0;
514 bool address_of = false;
515 ValueObjectSP valobj_sp;
516 const bool get_file_globals = true;
517 // When looking up a variable for an expression, we need only consider the
518 // variables that are in scope.
519 VariableListSP var_list_sp(GetInScopeVariableList(get_file_globals));
520 VariableList *variable_list = var_list_sp.get();
523 return ValueObjectSP();
525 // If first character is a '*', then show pointer contents
526 std::string var_expr_storage;
527 if (var_expr[0] == '*') {
529 var_expr = var_expr.drop_front(); // Skip the '*'
530 } else if (var_expr[0] == '&') {
532 var_expr = var_expr.drop_front(); // Skip the '&'
535 size_t separator_idx = var_expr.find_first_of(".-[=+~|&^%#@!/?,<>{}");
536 StreamString var_expr_path_strm;
538 ConstString name_const_string(var_expr.substr(0, separator_idx));
540 var_sp = variable_list->FindVariable(name_const_string, false);
542 bool synthetically_added_instance_object = false;
545 var_expr = var_expr.drop_front(name_const_string.GetLength());
548 if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
549 // Check for direct ivars access which helps us with implicit
550 // access to ivars with the "this->" or "self->"
551 GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock);
552 lldb::LanguageType method_language = eLanguageTypeUnknown;
553 bool is_instance_method = false;
554 ConstString method_object_name;
555 if (m_sc.GetFunctionMethodInfo(method_language, is_instance_method,
556 method_object_name)) {
557 if (is_instance_method && method_object_name) {
558 var_sp = variable_list->FindVariable(method_object_name);
561 var_expr_storage = "->";
562 var_expr_storage += var_expr;
563 var_expr = var_expr_storage;
564 synthetically_added_instance_object = true;
570 if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
571 // Check if any anonymous unions are there which contain a variable with
573 for (size_t i = 0; i < variable_list->GetSize(); i++) {
574 VariableSP variable_sp = variable_list->GetVariableAtIndex(i);
577 if (!variable_sp->GetName().IsEmpty())
580 Type *var_type = variable_sp->GetType();
584 if (!var_type->GetForwardCompilerType().IsAnonymousType())
586 valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
589 valobj_sp = valobj_sp->GetChildMemberWithName(name_const_string, true);
595 if (var_sp && !valobj_sp) {
596 valobj_sp = GetValueObjectForFrameVariable(var_sp, use_dynamic);
601 error.SetErrorStringWithFormat("no variable named '%s' found in this frame",
602 name_const_string.GetCString());
603 return ValueObjectSP();
606 // We are dumping at least one child
607 while (separator_idx != std::string::npos) {
608 // Calculate the next separator index ahead of time
609 ValueObjectSP child_valobj_sp;
610 const char separator_type = var_expr[0];
611 bool expr_is_ptr = false;
612 switch (separator_type) {
615 if (var_expr.size() >= 2 && var_expr[1] != '>')
616 return ValueObjectSP();
618 if (no_fragile_ivar) {
619 // Make sure we aren't trying to deref an objective
620 // C ivar if this is not allowed
621 const uint32_t pointer_type_flags =
622 valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
623 if ((pointer_type_flags & eTypeIsObjC) &&
624 (pointer_type_flags & eTypeIsPointer)) {
625 // This was an objective C object pointer and
626 // it was requested we skip any fragile ivars
627 // so return nothing here
628 return ValueObjectSP();
632 // If we have a non pointer type with a sythetic value then lets check if
633 // we have an sythetic dereference specified.
634 if (!valobj_sp->IsPointerType() && valobj_sp->HasSyntheticValue()) {
636 if (valobj_sp->GetCompilerType().IsReferenceType()) {
637 valobj_sp = valobj_sp->GetSyntheticValue()->Dereference(deref_error);
639 error.SetErrorStringWithFormatv(
640 "Failed to dereference reference type: %s", deref_error);
641 return ValueObjectSP();
645 valobj_sp = valobj_sp->Dereference(deref_error);
647 error.SetErrorStringWithFormatv(
648 "Failed to dereference sythetic value: %s", deref_error);
649 return ValueObjectSP();
654 var_expr = var_expr.drop_front(); // Remove the '-'
657 var_expr = var_expr.drop_front(); // Remove the '.' or '>'
658 separator_idx = var_expr.find_first_of(".-[");
659 ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));
661 if (check_ptr_vs_member) {
662 // We either have a pointer type and need to verify
663 // valobj_sp is a pointer, or we have a member of a
664 // class/union/struct being accessed with the . syntax
665 // and need to verify we don't have a pointer.
666 const bool actual_is_ptr = valobj_sp->IsPointerType();
668 if (actual_is_ptr != expr_is_ptr) {
669 // Incorrect use of "." with a pointer, or "->" with
670 // a class/union/struct instance or reference.
671 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
673 error.SetErrorStringWithFormat(
674 "\"%s\" is a pointer and . was used to attempt to access "
675 "\"%s\". Did you mean \"%s->%s\"?",
676 var_expr_path_strm.GetData(), child_name.GetCString(),
677 var_expr_path_strm.GetData(), var_expr.str().c_str());
679 error.SetErrorStringWithFormat(
680 "\"%s\" is not a pointer and -> was used to attempt to "
681 "access \"%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 return ValueObjectSP();
687 child_valobj_sp = valobj_sp->GetChildMemberWithName(child_name, true);
688 if (!child_valobj_sp) {
689 if (!no_synth_child) {
690 child_valobj_sp = valobj_sp->GetSyntheticValue();
693 child_valobj_sp->GetChildMemberWithName(child_name, true);
696 if (no_synth_child || !child_valobj_sp) {
697 // No child member with name "child_name"
698 if (synthetically_added_instance_object) {
699 // We added a "this->" or "self->" to the beginning of the
701 // and this is the first pointer ivar access, so just return
704 error.SetErrorStringWithFormat(
705 "no variable or instance variable named '%s' found in "
707 name_const_string.GetCString());
709 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
711 error.SetErrorStringWithFormat(
712 "\"%s\" is not a member of \"(%s) %s\"",
713 child_name.GetCString(),
714 valobj_sp->GetTypeName().AsCString("<invalid type>"),
715 var_expr_path_strm.GetData());
717 error.SetErrorStringWithFormat(
718 "incomplete expression path after \"%s\" in \"%s\"",
719 var_expr_path_strm.GetData(),
720 original_var_expr.str().c_str());
723 return ValueObjectSP();
726 synthetically_added_instance_object = false;
727 // Remove the child name from the path
728 var_expr = var_expr.drop_front(child_name.GetLength());
729 if (use_dynamic != eNoDynamicValues) {
730 ValueObjectSP dynamic_value_sp(
731 child_valobj_sp->GetDynamicValue(use_dynamic));
732 if (dynamic_value_sp)
733 child_valobj_sp = dynamic_value_sp;
738 // Array member access, or treating pointer as an array
739 // Need at least two brackets and a number
740 if (var_expr.size() <= 2) {
741 error.SetErrorStringWithFormat(
742 "invalid square bracket encountered after \"%s\" in \"%s\"",
743 var_expr_path_strm.GetData(), var_expr.str().c_str());
744 return ValueObjectSP();
747 // Drop the open brace.
748 var_expr = var_expr.drop_front();
749 long child_index = 0;
751 // If there's no closing brace, this is an invalid expression.
752 size_t end_pos = var_expr.find_first_of(']');
753 if (end_pos == llvm::StringRef::npos) {
754 error.SetErrorStringWithFormat(
755 "missing closing square bracket in expression \"%s\"",
756 var_expr_path_strm.GetData());
757 return ValueObjectSP();
759 llvm::StringRef index_expr = var_expr.take_front(end_pos);
760 llvm::StringRef original_index_expr = index_expr;
761 // Drop all of "[index_expr]"
762 var_expr = var_expr.drop_front(end_pos + 1);
764 if (index_expr.consumeInteger(0, child_index)) {
765 // If there was no integer anywhere in the index expression, this is
766 // erroneous expression.
767 error.SetErrorStringWithFormat("invalid index expression \"%s\"",
768 index_expr.str().c_str());
769 return ValueObjectSP();
772 if (index_expr.empty()) {
773 // The entire index expression was a single integer.
775 if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
776 // what we have is *ptr[low]. the most similar C++ syntax is to deref
777 // ptr and extract bit low out of it. reading array item low would be
778 // done by saying ptr[low], without a deref * sign
780 ValueObjectSP temp(valobj_sp->Dereference(error));
782 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
783 error.SetErrorStringWithFormat(
784 "could not dereference \"(%s) %s\"",
785 valobj_sp->GetTypeName().AsCString("<invalid type>"),
786 var_expr_path_strm.GetData());
787 return ValueObjectSP();
791 } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
793 // what we have is *arr[low]. the most similar C++ syntax is
795 // (an operation that is equivalent to deref-ing arr)
796 // and extract bit low out of it. reading array item low
797 // would be done by saying arr[low], without a deref * sign
799 ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
801 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
802 error.SetErrorStringWithFormat(
803 "could not get item 0 for \"(%s) %s\"",
804 valobj_sp->GetTypeName().AsCString("<invalid type>"),
805 var_expr_path_strm.GetData());
806 return ValueObjectSP();
812 bool is_incomplete_array = false;
813 if (valobj_sp->IsPointerType()) {
814 bool is_objc_pointer = true;
816 if (valobj_sp->GetCompilerType().GetMinimumLanguage() !=
818 is_objc_pointer = false;
819 else if (!valobj_sp->GetCompilerType().IsPointerType())
820 is_objc_pointer = false;
822 if (no_synth_child && is_objc_pointer) {
823 error.SetErrorStringWithFormat(
824 "\"(%s) %s\" is an Objective-C pointer, and cannot be "
826 valobj_sp->GetTypeName().AsCString("<invalid type>"),
827 var_expr_path_strm.GetData());
829 return ValueObjectSP();
830 } else if (is_objc_pointer) {
831 // dereferencing ObjC variables is not valid.. so let's try
832 // and recur to synthetic children
833 ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
834 if (!synthetic /* no synthetic */
835 || synthetic == valobj_sp) /* synthetic is the same as
836 the original object */
838 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
839 error.SetErrorStringWithFormat(
840 "\"(%s) %s\" is not an array type",
841 valobj_sp->GetTypeName().AsCString("<invalid type>"),
842 var_expr_path_strm.GetData());
844 static_cast<uint32_t>(child_index) >=
846 ->GetNumChildren() /* synthetic does not have that many values */) {
847 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
848 error.SetErrorStringWithFormat(
849 "array index %ld is not valid for \"(%s) %s\"", child_index,
850 valobj_sp->GetTypeName().AsCString("<invalid type>"),
851 var_expr_path_strm.GetData());
853 child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
854 if (!child_valobj_sp) {
855 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
856 error.SetErrorStringWithFormat(
857 "array index %ld is not valid for \"(%s) %s\"", child_index,
858 valobj_sp->GetTypeName().AsCString("<invalid type>"),
859 var_expr_path_strm.GetData());
864 valobj_sp->GetSyntheticArrayMember(child_index, true);
865 if (!child_valobj_sp) {
866 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
867 error.SetErrorStringWithFormat(
868 "failed to use pointer as array for index %ld for "
871 valobj_sp->GetTypeName().AsCString("<invalid type>"),
872 var_expr_path_strm.GetData());
875 } else if (valobj_sp->GetCompilerType().IsArrayType(
876 nullptr, nullptr, &is_incomplete_array)) {
877 // Pass false to dynamic_value here so we can tell the
878 // difference between
879 // no dynamic value and no member of this type...
880 child_valobj_sp = valobj_sp->GetChildAtIndex(child_index, true);
881 if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
883 valobj_sp->GetSyntheticArrayMember(child_index, true);
885 if (!child_valobj_sp) {
886 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
887 error.SetErrorStringWithFormat(
888 "array index %ld is not valid for \"(%s) %s\"", child_index,
889 valobj_sp->GetTypeName().AsCString("<invalid type>"),
890 var_expr_path_strm.GetData());
892 } else if (valobj_sp->GetCompilerType().IsScalarType()) {
893 // this is a bitfield asking to display just one bit
894 child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
895 child_index, child_index, true);
896 if (!child_valobj_sp) {
897 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
898 error.SetErrorStringWithFormat(
899 "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
900 child_index, child_index,
901 valobj_sp->GetTypeName().AsCString("<invalid type>"),
902 var_expr_path_strm.GetData());
905 ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
906 if (no_synth_child /* synthetic is forbidden */ ||
907 !synthetic /* no synthetic */
908 || synthetic == valobj_sp) /* synthetic is the same as the
911 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
912 error.SetErrorStringWithFormat(
913 "\"(%s) %s\" is not an array type",
914 valobj_sp->GetTypeName().AsCString("<invalid type>"),
915 var_expr_path_strm.GetData());
917 static_cast<uint32_t>(child_index) >=
919 ->GetNumChildren() /* synthetic does not have that many values */) {
920 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
921 error.SetErrorStringWithFormat(
922 "array index %ld is not valid for \"(%s) %s\"", child_index,
923 valobj_sp->GetTypeName().AsCString("<invalid type>"),
924 var_expr_path_strm.GetData());
926 child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
927 if (!child_valobj_sp) {
928 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
929 error.SetErrorStringWithFormat(
930 "array index %ld is not valid for \"(%s) %s\"", child_index,
931 valobj_sp->GetTypeName().AsCString("<invalid type>"),
932 var_expr_path_strm.GetData());
937 if (!child_valobj_sp) {
938 // Invalid array index...
939 return ValueObjectSP();
942 separator_idx = var_expr.find_first_of(".-[");
943 if (use_dynamic != eNoDynamicValues) {
944 ValueObjectSP dynamic_value_sp(
945 child_valobj_sp->GetDynamicValue(use_dynamic));
946 if (dynamic_value_sp)
947 child_valobj_sp = dynamic_value_sp;
949 // Break out early from the switch since we were able to find the child
954 // this is most probably a BitField, let's take a look
955 if (index_expr.front() != '-') {
956 error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
957 original_index_expr.str().c_str());
958 return ValueObjectSP();
961 index_expr = index_expr.drop_front();
962 long final_index = 0;
963 if (index_expr.getAsInteger(0, final_index)) {
964 error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
965 original_index_expr.str().c_str());
966 return ValueObjectSP();
969 // if the format given is [high-low], swap range
970 if (child_index > final_index) {
971 long temp = child_index;
972 child_index = final_index;
976 if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
977 // what we have is *ptr[low-high]. the most similar C++ syntax is to
978 // deref ptr and extract bits low thru high out of it. reading array
979 // items low thru high would be done by saying ptr[low-high], without
982 ValueObjectSP temp(valobj_sp->Dereference(error));
984 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
985 error.SetErrorStringWithFormat(
986 "could not dereference \"(%s) %s\"",
987 valobj_sp->GetTypeName().AsCString("<invalid type>"),
988 var_expr_path_strm.GetData());
989 return ValueObjectSP();
993 } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref) {
994 // what we have is *arr[low-high]. the most similar C++ syntax is to get
995 // arr[0] (an operation that is equivalent to deref-ing arr) and extract
996 // bits low thru high out of it. reading array items low thru high would
997 // be done by saying arr[low-high], without a deref * sign
999 ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
1001 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
1002 error.SetErrorStringWithFormat(
1003 "could not get item 0 for \"(%s) %s\"",
1004 valobj_sp->GetTypeName().AsCString("<invalid type>"),
1005 var_expr_path_strm.GetData());
1006 return ValueObjectSP();
1013 valobj_sp->GetSyntheticBitFieldChild(child_index, final_index, true);
1014 if (!child_valobj_sp) {
1015 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
1016 error.SetErrorStringWithFormat(
1017 "bitfield range %ld-%ld is not valid for \"(%s) %s\"", child_index,
1018 final_index, valobj_sp->GetTypeName().AsCString("<invalid type>"),
1019 var_expr_path_strm.GetData());
1022 if (!child_valobj_sp) {
1023 // Invalid bitfield range...
1024 return ValueObjectSP();
1027 separator_idx = var_expr.find_first_of(".-[");
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;
1034 // Break out early from the switch since we were able to find the child
1041 valobj_sp->GetExpressionPath(var_expr_path_strm, false);
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());
1047 return ValueObjectSP();
1051 if (child_valobj_sp)
1052 valobj_sp = child_valobj_sp;
1054 if (var_expr.empty())
1059 ValueObjectSP deref_valobj_sp(valobj_sp->Dereference(error));
1060 valobj_sp = deref_valobj_sp;
1061 } else if (address_of) {
1062 ValueObjectSP address_of_valobj_sp(valobj_sp->AddressOf(error));
1063 valobj_sp = address_of_valobj_sp;
1069 bool StackFrame::GetFrameBaseValue(Scalar &frame_base, Status *error_ptr) {
1070 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1071 if (!m_cfa_is_valid) {
1072 m_frame_base_error.SetErrorString(
1073 "No frame base available for this historical stack frame.");
1077 if (m_flags.IsClear(GOT_FRAME_BASE)) {
1078 if (m_sc.function) {
1079 m_frame_base.Clear();
1080 m_frame_base_error.Clear();
1082 m_flags.Set(GOT_FRAME_BASE);
1083 ExecutionContext exe_ctx(shared_from_this());
1085 addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
1086 if (m_sc.function->GetFrameBaseExpression().IsLocationList())
1088 m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
1089 exe_ctx.GetTargetPtr());
1091 if (m_sc.function->GetFrameBaseExpression().Evaluate(
1092 &exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr,
1093 expr_value, &m_frame_base_error) == false) {
1094 // We should really have an error if evaluate returns, but in case
1095 // we don't, lets set the error to something at least.
1096 if (m_frame_base_error.Success())
1097 m_frame_base_error.SetErrorString(
1098 "Evaluation of the frame base expression failed.");
1100 m_frame_base = expr_value.ResolveValue(&exe_ctx);
1103 m_frame_base_error.SetErrorString("No function in symbol context.");
1107 if (m_frame_base_error.Success())
1108 frame_base = m_frame_base;
1111 *error_ptr = m_frame_base_error;
1112 return m_frame_base_error.Success();
1115 DWARFExpression *StackFrame::GetFrameBaseExpression(Status *error_ptr) {
1116 if (!m_sc.function) {
1118 error_ptr->SetErrorString("No function in symbol context.");
1123 return &m_sc.function->GetFrameBaseExpression();
1126 RegisterContextSP StackFrame::GetRegisterContext() {
1127 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1128 if (!m_reg_context_sp) {
1129 ThreadSP thread_sp(GetThread());
1131 m_reg_context_sp = thread_sp->CreateRegisterContextForFrame(this);
1133 return m_reg_context_sp;
1136 bool StackFrame::HasDebugInformation() {
1137 GetSymbolContext(eSymbolContextLineEntry);
1138 return m_sc.line_entry.IsValid();
1142 StackFrame::GetValueObjectForFrameVariable(const VariableSP &variable_sp,
1143 DynamicValueType use_dynamic) {
1144 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1145 ValueObjectSP valobj_sp;
1146 if (m_is_history_frame) {
1149 VariableList *var_list = GetVariableList(true);
1151 // Make sure the variable is a frame variable
1152 const uint32_t var_idx = var_list->FindIndexForVariable(variable_sp.get());
1153 const uint32_t num_variables = var_list->GetSize();
1154 if (var_idx < num_variables) {
1155 valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex(var_idx);
1157 if (m_variable_list_value_objects.GetSize() < num_variables)
1158 m_variable_list_value_objects.Resize(num_variables);
1159 valobj_sp = ValueObjectVariable::Create(this, variable_sp);
1160 m_variable_list_value_objects.SetValueObjectAtIndex(var_idx, valobj_sp);
1164 if (use_dynamic != eNoDynamicValues && valobj_sp) {
1165 ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue(use_dynamic);
1172 ValueObjectSP StackFrame::TrackGlobalVariable(const VariableSP &variable_sp,
1173 DynamicValueType use_dynamic) {
1174 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1175 if (m_is_history_frame)
1176 return ValueObjectSP();
1178 // Check to make sure we aren't already tracking this variable?
1179 ValueObjectSP valobj_sp(
1180 GetValueObjectForFrameVariable(variable_sp, use_dynamic));
1182 // We aren't already tracking this global
1183 VariableList *var_list = GetVariableList(true);
1184 // If this frame has no variables, create a new list
1185 if (var_list == nullptr)
1186 m_variable_list_sp.reset(new VariableList());
1188 // Add the global/static variable to this frame
1189 m_variable_list_sp->AddVariable(variable_sp);
1191 // Now make a value object for it so we can track its changes
1192 valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
1197 bool StackFrame::IsInlined() {
1198 if (m_sc.block == nullptr)
1199 GetSymbolContext(eSymbolContextBlock);
1201 return m_sc.block->GetContainingInlinedBlock() != nullptr;
1205 lldb::LanguageType StackFrame::GetLanguage() {
1206 CompileUnit *cu = GetSymbolContext(eSymbolContextCompUnit).comp_unit;
1208 return cu->GetLanguage();
1209 return lldb::eLanguageTypeUnknown;
1212 lldb::LanguageType StackFrame::GuessLanguage() {
1213 LanguageType lang_type = GetLanguage();
1215 if (lang_type == eLanguageTypeUnknown) {
1216 SymbolContext sc = GetSymbolContext(eSymbolContextFunction
1217 | eSymbolContextSymbol);
1219 lang_type = sc.function->GetMangled().GuessLanguage();
1223 lang_type = sc.symbol->GetMangled().GuessLanguage();
1231 std::pair<const Instruction::Operand *, int64_t>
1232 GetBaseExplainingValue(const Instruction::Operand &operand,
1233 RegisterContext ®ister_context, lldb::addr_t value) {
1234 switch (operand.m_type) {
1235 case Instruction::Operand::Type::Dereference:
1236 case Instruction::Operand::Type::Immediate:
1237 case Instruction::Operand::Type::Invalid:
1238 case Instruction::Operand::Type::Product:
1239 // These are not currently interesting
1240 return std::make_pair(nullptr, 0);
1241 case Instruction::Operand::Type::Sum: {
1242 const Instruction::Operand *immediate_child = nullptr;
1243 const Instruction::Operand *variable_child = nullptr;
1244 if (operand.m_children[0].m_type == Instruction::Operand::Type::Immediate) {
1245 immediate_child = &operand.m_children[0];
1246 variable_child = &operand.m_children[1];
1247 } else if (operand.m_children[1].m_type ==
1248 Instruction::Operand::Type::Immediate) {
1249 immediate_child = &operand.m_children[1];
1250 variable_child = &operand.m_children[0];
1252 if (!immediate_child) {
1253 return std::make_pair(nullptr, 0);
1255 lldb::addr_t adjusted_value = value;
1256 if (immediate_child->m_negative) {
1257 adjusted_value += immediate_child->m_immediate;
1259 adjusted_value -= immediate_child->m_immediate;
1261 std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1262 GetBaseExplainingValue(*variable_child, register_context,
1264 if (!base_and_offset.first) {
1265 return std::make_pair(nullptr, 0);
1267 if (immediate_child->m_negative) {
1268 base_and_offset.second -= immediate_child->m_immediate;
1270 base_and_offset.second += immediate_child->m_immediate;
1272 return base_and_offset;
1274 case Instruction::Operand::Type::Register: {
1275 const RegisterInfo *info =
1276 register_context.GetRegisterInfoByName(operand.m_register.AsCString());
1278 return std::make_pair(nullptr, 0);
1280 RegisterValue reg_value;
1281 if (!register_context.ReadRegister(info, reg_value)) {
1282 return std::make_pair(nullptr, 0);
1284 if (reg_value.GetAsUInt64() == value) {
1285 return std::make_pair(&operand, 0);
1287 return std::make_pair(nullptr, 0);
1291 return std::make_pair(nullptr, 0);
1294 std::pair<const Instruction::Operand *, int64_t>
1295 GetBaseExplainingDereference(const Instruction::Operand &operand,
1296 RegisterContext ®ister_context,
1297 lldb::addr_t addr) {
1298 if (operand.m_type == Instruction::Operand::Type::Dereference) {
1299 return GetBaseExplainingValue(operand.m_children[0], register_context,
1302 return std::make_pair(nullptr, 0);
1306 lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
1307 TargetSP target_sp = CalculateTarget();
1309 const ArchSpec &target_arch = target_sp->GetArchitecture();
1311 AddressRange pc_range;
1312 pc_range.GetBaseAddress() = GetFrameCodeAddress();
1313 pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
1315 ExecutionContext exe_ctx(shared_from_this());
1317 const char *plugin_name = nullptr;
1318 const char *flavor = nullptr;
1319 const bool prefer_file_cache = false;
1321 DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1322 target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
1324 if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1325 return ValueObjectSP();
1328 InstructionSP instruction_sp =
1329 disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
1331 llvm::SmallVector<Instruction::Operand, 3> operands;
1333 if (!instruction_sp->ParseOperands(operands)) {
1334 return ValueObjectSP();
1337 RegisterContextSP register_context_sp = GetRegisterContext();
1339 if (!register_context_sp) {
1340 return ValueObjectSP();
1343 for (const Instruction::Operand &operand : operands) {
1344 std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1345 GetBaseExplainingDereference(operand, *register_context_sp, addr);
1347 if (!base_and_offset.first) {
1351 switch (base_and_offset.first->m_type) {
1352 case Instruction::Operand::Type::Immediate: {
1353 lldb_private::Address addr;
1354 if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
1355 base_and_offset.second,
1357 TypeSystem *c_type_system =
1358 target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
1359 if (!c_type_system) {
1360 return ValueObjectSP();
1362 CompilerType void_ptr_type =
1364 ->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
1366 return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
1369 return ValueObjectSP();
1373 case Instruction::Operand::Type::Register: {
1374 return GuessValueForRegisterAndOffset(base_and_offset.first->m_register,
1375 base_and_offset.second);
1378 return ValueObjectSP();
1382 return ValueObjectSP();
1386 ValueObjectSP GetValueForOffset(StackFrame &frame, ValueObjectSP &parent,
1388 if (offset < 0 || uint64_t(offset) >= parent->GetByteSize()) {
1389 return ValueObjectSP();
1392 if (parent->IsPointerOrReferenceType()) {
1396 for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci) {
1397 const bool can_create = true;
1398 ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
1401 return ValueObjectSP();
1404 int64_t child_offset = child_sp->GetByteOffset();
1405 int64_t child_size = child_sp->GetByteSize();
1407 if (offset >= child_offset && offset < (child_offset + child_size)) {
1408 return GetValueForOffset(frame, child_sp, offset - child_offset);
1415 return ValueObjectSP();
1419 ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
1420 ValueObjectSP &base,
1422 // base is a pointer to something
1423 // offset is the thing to add to the pointer
1424 // We return the most sensible ValueObject for the result of *(base+offset)
1426 if (!base->IsPointerOrReferenceType()) {
1427 return ValueObjectSP();
1431 ValueObjectSP pointee = base->Dereference(error);
1434 return ValueObjectSP();
1437 if (offset >= 0 && uint64_t(offset) >= pointee->GetByteSize()) {
1438 int64_t index = offset / pointee->GetByteSize();
1439 offset = offset % pointee->GetByteSize();
1440 const bool can_create = true;
1441 pointee = base->GetSyntheticArrayMember(index, can_create);
1444 if (!pointee || error.Fail()) {
1445 return ValueObjectSP();
1448 return GetValueForOffset(frame, pointee, offset);
1451 //------------------------------------------------------------------
1452 /// Attempt to reconstruct the ValueObject for the address contained in a
1453 /// given register plus an offset.
1455 /// @params [in] frame
1456 /// The current stack frame.
1458 /// @params [in] reg
1461 /// @params [in] offset
1462 /// The offset from the register.
1464 /// @param [in] disassembler
1465 /// A disassembler containing instructions valid up to the current PC.
1467 /// @param [in] variables
1468 /// The variable list from the current frame,
1471 /// The program counter for the instruction considered the 'user'.
1474 /// A string describing the base for the ExpressionPath. This could be a
1475 /// variable, a register value, an argument, or a function return value.
1476 /// The ValueObject if found. If valid, it has a valid ExpressionPath.
1477 //------------------------------------------------------------------
1478 lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
1479 int64_t offset, Disassembler &disassembler,
1480 VariableList &variables, const Address &pc) {
1481 // Example of operation for Intel:
1483 // +14: movq -0x8(%rbp), %rdi
1484 // +18: movq 0x8(%rdi), %rdi
1485 // +22: addl 0x4(%rdi), %eax
1487 // f, a pointer to a struct, is known to be at -0x8(%rbp).
1489 // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at +18
1490 // that assigns to rdi, and calls itself recursively for that dereference
1491 // DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
1492 // +14 that assigns to rdi, and calls itself recursively for that
1494 // DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the
1496 // Returns a ValueObject for f. (That's what was stored at rbp-8 at +14)
1497 // Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
1499 // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
1502 // First, check the variable list to see if anything is at the specified
1505 using namespace OperandMatchers;
1507 const RegisterInfo *reg_info =
1508 frame.GetRegisterContext()->GetRegisterInfoByName(reg.AsCString());
1510 return ValueObjectSP();
1513 Instruction::Operand op =
1514 offset ? Instruction::Operand::BuildDereference(
1515 Instruction::Operand::BuildSum(
1516 Instruction::Operand::BuildRegister(reg),
1517 Instruction::Operand::BuildImmediate(offset)))
1518 : Instruction::Operand::BuildDereference(
1519 Instruction::Operand::BuildRegister(reg));
1521 for (size_t vi = 0, ve = variables.GetSize(); vi != ve; ++vi) {
1522 VariableSP var_sp = variables.GetVariableAtIndex(vi);
1523 if (var_sp->LocationExpression().MatchesOperand(frame, op)) {
1524 return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
1528 const uint32_t current_inst =
1529 disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(pc);
1530 if (current_inst == UINT32_MAX) {
1531 return ValueObjectSP();
1534 for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {
1535 // This is not an exact algorithm, and it sacrifices accuracy for
1536 // generality. Recognizing "mov" and "ld" instructions –– and which are
1537 // their source and destination operands -- is something the disassembler
1538 // should do for us.
1539 InstructionSP instruction_sp =
1540 disassembler.GetInstructionList().GetInstructionAtIndex(ii);
1542 if (instruction_sp->IsCall()) {
1543 ABISP abi_sp = frame.CalculateProcess()->GetABI();
1548 const char *return_register_name;
1549 if (!abi_sp->GetPointerReturnRegister(return_register_name)) {
1553 const RegisterInfo *return_register_info =
1554 frame.GetRegisterContext()->GetRegisterInfoByName(
1555 return_register_name);
1556 if (!return_register_info) {
1562 if (!MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference),
1563 MatchRegOp(*return_register_info))(op) &&
1565 MatchOpType(Instruction::Operand::Type::Dereference),
1566 MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
1567 MatchRegOp(*return_register_info),
1568 FetchImmOp(offset)))(op)) {
1572 llvm::SmallVector<Instruction::Operand, 1> operands;
1573 if (!instruction_sp->ParseOperands(operands) || operands.size() != 1) {
1577 switch (operands[0].m_type) {
1580 case Instruction::Operand::Type::Immediate: {
1582 Address load_address;
1583 if (!frame.CalculateTarget()->ResolveLoadAddress(
1584 operands[0].m_immediate, load_address)) {
1587 frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(
1588 load_address, eSymbolContextFunction, sc);
1592 CompilerType function_type = sc.function->GetCompilerType();
1593 if (!function_type.IsFunctionType()) {
1596 CompilerType return_type = function_type.GetFunctionReturnType();
1597 RegisterValue return_value;
1598 if (!frame.GetRegisterContext()->ReadRegister(return_register_info,
1602 std::string name_str(
1603 sc.function->GetName().AsCString("<unknown function>"));
1604 name_str.append("()");
1605 Address return_value_address(return_value.GetAsUInt64());
1606 ValueObjectSP return_value_sp = ValueObjectMemory::Create(
1607 &frame, name_str, return_value_address, return_type);
1608 return GetValueForDereferincingOffset(frame, return_value_sp, offset);
1615 llvm::SmallVector<Instruction::Operand, 2> operands;
1616 if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
1620 Instruction::Operand *origin_operand = nullptr;
1621 auto clobbered_reg_matcher = [reg_info](const Instruction::Operand &op) {
1622 return MatchRegOp(*reg_info)(op) && op.m_clobbered;
1625 if (clobbered_reg_matcher(operands[0])) {
1626 origin_operand = &operands[1];
1628 else if (clobbered_reg_matcher(operands[1])) {
1629 origin_operand = &operands[0];
1635 // We have an origin operand. Can we track its value down?
1636 ValueObjectSP source_path;
1637 ConstString origin_register;
1638 int64_t origin_offset = 0;
1640 if (FetchRegOp(origin_register)(*origin_operand)) {
1641 source_path = DoGuessValueAt(frame, origin_register, 0, disassembler,
1642 variables, instruction_sp->GetAddress());
1643 } else if (MatchUnaryOp(
1644 MatchOpType(Instruction::Operand::Type::Dereference),
1645 FetchRegOp(origin_register))(*origin_operand) ||
1647 MatchOpType(Instruction::Operand::Type::Dereference),
1648 MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
1649 FetchRegOp(origin_register),
1650 FetchImmOp(origin_offset)))(*origin_operand)) {
1652 DoGuessValueAt(frame, origin_register, origin_offset, disassembler,
1653 variables, instruction_sp->GetAddress());
1658 GetValueForDereferincingOffset(frame, source_path, offset);
1666 return ValueObjectSP();
1670 lldb::ValueObjectSP StackFrame::GuessValueForRegisterAndOffset(ConstString reg,
1672 TargetSP target_sp = CalculateTarget();
1674 const ArchSpec &target_arch = target_sp->GetArchitecture();
1676 Block *frame_block = GetFrameBlock();
1679 return ValueObjectSP();
1682 Function *function = frame_block->CalculateSymbolContextFunction();
1684 return ValueObjectSP();
1687 AddressRange pc_range = function->GetAddressRange();
1689 if (GetFrameCodeAddress().GetFileAddress() <
1690 pc_range.GetBaseAddress().GetFileAddress() ||
1691 GetFrameCodeAddress().GetFileAddress() -
1692 pc_range.GetBaseAddress().GetFileAddress() >=
1693 pc_range.GetByteSize()) {
1694 return ValueObjectSP();
1697 ExecutionContext exe_ctx(shared_from_this());
1699 const char *plugin_name = nullptr;
1700 const char *flavor = nullptr;
1701 const bool prefer_file_cache = false;
1702 DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1703 target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
1705 if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1706 return ValueObjectSP();
1709 const bool get_file_globals = false;
1710 VariableList *variables = GetVariableList(get_file_globals);
1713 return ValueObjectSP();
1716 return DoGuessValueAt(*this, reg, offset, *disassembler_sp, *variables,
1717 GetFrameCodeAddress());
1720 TargetSP StackFrame::CalculateTarget() {
1722 ThreadSP thread_sp(GetThread());
1724 ProcessSP process_sp(thread_sp->CalculateProcess());
1726 target_sp = process_sp->CalculateTarget();
1731 ProcessSP StackFrame::CalculateProcess() {
1732 ProcessSP process_sp;
1733 ThreadSP thread_sp(GetThread());
1735 process_sp = thread_sp->CalculateProcess();
1739 ThreadSP StackFrame::CalculateThread() { return GetThread(); }
1741 StackFrameSP StackFrame::CalculateStackFrame() { return shared_from_this(); }
1743 void StackFrame::CalculateExecutionContext(ExecutionContext &exe_ctx) {
1744 exe_ctx.SetContext(shared_from_this());
1747 void StackFrame::DumpUsingSettingsFormat(Stream *strm, bool show_unique,
1748 const char *frame_marker) {
1749 if (strm == nullptr)
1752 GetSymbolContext(eSymbolContextEverything);
1753 ExecutionContext exe_ctx(shared_from_this());
1757 s.PutCString(frame_marker);
1759 const FormatEntity::Entry *frame_format = nullptr;
1760 Target *target = exe_ctx.GetTargetPtr();
1763 frame_format = target->GetDebugger().GetFrameFormatUnique();
1765 frame_format = target->GetDebugger().GetFrameFormat();
1768 if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx,
1769 nullptr, nullptr, false, false)) {
1770 strm->PutCString(s.GetString());
1772 Dump(strm, true, false);
1777 void StackFrame::Dump(Stream *strm, bool show_frame_index,
1778 bool show_fullpaths) {
1779 if (strm == nullptr)
1782 if (show_frame_index)
1783 strm->Printf("frame #%u: ", m_frame_index);
1784 ExecutionContext exe_ctx(shared_from_this());
1785 Target *target = exe_ctx.GetTargetPtr();
1786 strm->Printf("0x%0*" PRIx64 " ",
1787 target ? (target->GetArchitecture().GetAddressByteSize() * 2)
1789 GetFrameCodeAddress().GetLoadAddress(target));
1790 GetSymbolContext(eSymbolContextEverything);
1791 const bool show_module = true;
1792 const bool show_inline = true;
1793 const bool show_function_arguments = true;
1794 const bool show_function_name = true;
1795 m_sc.DumpStopContext(strm, exe_ctx.GetBestExecutionContextScope(),
1796 GetFrameCodeAddress(), show_fullpaths, show_module,
1797 show_inline, show_function_arguments,
1798 show_function_name);
1801 void StackFrame::UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame) {
1802 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1803 assert(GetStackID() ==
1804 prev_frame.GetStackID()); // TODO: remove this after some testing
1805 m_variable_list_sp = prev_frame.m_variable_list_sp;
1806 m_variable_list_value_objects.Swap(prev_frame.m_variable_list_value_objects);
1807 if (!m_disassembly.GetString().empty()) {
1808 m_disassembly.Clear();
1809 m_disassembly.PutCString(prev_frame.m_disassembly.GetString());
1813 void StackFrame::UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame) {
1814 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1815 assert(GetStackID() ==
1816 curr_frame.GetStackID()); // TODO: remove this after some testing
1817 m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value
1818 assert(GetThread() == curr_frame.GetThread());
1819 m_frame_index = curr_frame.m_frame_index;
1820 m_concrete_frame_index = curr_frame.m_concrete_frame_index;
1821 m_reg_context_sp = curr_frame.m_reg_context_sp;
1822 m_frame_code_addr = curr_frame.m_frame_code_addr;
1823 assert(!m_sc.target_sp || !curr_frame.m_sc.target_sp ||
1824 m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
1825 assert(!m_sc.module_sp || !curr_frame.m_sc.module_sp ||
1826 m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
1827 assert(m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr ||
1828 m_sc.comp_unit == curr_frame.m_sc.comp_unit);
1829 assert(m_sc.function == nullptr || curr_frame.m_sc.function == nullptr ||
1830 m_sc.function == curr_frame.m_sc.function);
1831 m_sc = curr_frame.m_sc;
1832 m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
1833 m_flags.Set(m_sc.GetResolvedMask());
1834 m_frame_base.Clear();
1835 m_frame_base_error.Clear();
1838 bool StackFrame::HasCachedData() const {
1839 if (m_variable_list_sp)
1841 if (m_variable_list_value_objects.GetSize() > 0)
1843 if (!m_disassembly.GetString().empty())
1848 bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
1849 bool show_unique, const char *frame_marker) {
1850 if (show_frame_info) {
1852 DumpUsingSettingsFormat(&strm, show_unique, frame_marker);
1856 ExecutionContext exe_ctx(shared_from_this());
1857 bool have_source = false, have_debuginfo = false;
1858 Debugger::StopDisassemblyType disasm_display =
1859 Debugger::eStopDisassemblyTypeNever;
1860 Target *target = exe_ctx.GetTargetPtr();
1862 Debugger &debugger = target->GetDebugger();
1863 const uint32_t source_lines_before =
1864 debugger.GetStopSourceLineCount(true);
1865 const uint32_t source_lines_after =
1866 debugger.GetStopSourceLineCount(false);
1867 disasm_display = debugger.GetStopDisassemblyDisplay();
1869 GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry);
1870 if (m_sc.comp_unit && m_sc.line_entry.IsValid()) {
1871 have_debuginfo = true;
1872 if (source_lines_before > 0 || source_lines_after > 0) {
1874 target->GetSourceManager().DisplaySourceLinesWithLineNumbers(
1875 m_sc.line_entry.file, m_sc.line_entry.line,
1876 m_sc.line_entry.column, source_lines_before,
1877 source_lines_after, "->", &strm);
1880 // TODO: Give here a one time warning if source file is missing.
1883 switch (disasm_display) {
1884 case Debugger::eStopDisassemblyTypeNever:
1887 case Debugger::eStopDisassemblyTypeNoDebugInfo:
1892 case Debugger::eStopDisassemblyTypeNoSource:
1897 case Debugger::eStopDisassemblyTypeAlways:
1899 const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
1900 if (disasm_lines > 0) {
1901 const ArchSpec &target_arch = target->GetArchitecture();
1902 AddressRange pc_range;
1903 pc_range.GetBaseAddress() = GetFrameCodeAddress();
1904 pc_range.SetByteSize(disasm_lines *
1905 target_arch.GetMaximumOpcodeByteSize());
1906 const char *plugin_name = nullptr;
1907 const char *flavor = nullptr;
1908 const bool mixed_source_and_assembly = false;
1909 Disassembler::Disassemble(
1910 target->GetDebugger(), target_arch, plugin_name, flavor,
1911 exe_ctx, pc_range, disasm_lines, mixed_source_and_assembly, 0,
1912 Disassembler::eOptionMarkPCAddress, strm);