maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Target/StackFrame.cpp

1969 lines
71 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

//===-- StackFrame.cpp ----------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/Target/StackFrame.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/FormatEntity.h"
#include "lldb/Core/Mangled.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ABI.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrameRecognizer.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/RegisterValue.h"
#include "lldb/lldb-enumerations.h"
#include <memory>
using namespace lldb;
using namespace lldb_private;
// The first bits in the flags are reserved for the SymbolContext::Scope bits
// so we know if we have tried to look up information in our internal symbol
// context (m_sc) already.
#define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
#define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
#define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
#define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1)
#define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1)
StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
user_id_t unwind_frame_index, addr_t cfa,
bool cfa_is_valid, addr_t pc, StackFrame::Kind kind,
bool behaves_like_zeroth_frame,
const SymbolContext *sc_ptr)
: m_thread_wp(thread_sp), m_frame_index(frame_idx),
m_concrete_frame_index(unwind_frame_index), m_reg_context_sp(),
m_id(pc, cfa, nullptr), m_frame_code_addr(pc), m_sc(), m_flags(),
m_frame_base(), m_frame_base_error(), m_cfa_is_valid(cfa_is_valid),
m_stack_frame_kind(kind),
m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
m_variable_list_sp(), m_variable_list_value_objects(),
m_recognized_frame_sp(), m_disassembly(), m_mutex() {
// If we don't have a CFA value, use the frame index for our StackID so that
// recursive functions properly aren't confused with one another on a history
// stack.
if (IsHistorical() && !m_cfa_is_valid) {
m_id.SetCFA(m_frame_index);
}
if (sc_ptr != nullptr) {
m_sc = *sc_ptr;
m_flags.Set(m_sc.GetResolvedMask());
}
}
StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
user_id_t unwind_frame_index,
const RegisterContextSP &reg_context_sp, addr_t cfa,
addr_t pc, bool behaves_like_zeroth_frame,
const SymbolContext *sc_ptr)
: m_thread_wp(thread_sp), m_frame_index(frame_idx),
m_concrete_frame_index(unwind_frame_index),
m_reg_context_sp(reg_context_sp), m_id(pc, cfa, nullptr),
m_frame_code_addr(pc), m_sc(), m_flags(), m_frame_base(),
m_frame_base_error(), m_cfa_is_valid(true),
m_stack_frame_kind(StackFrame::Kind::Regular),
m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
m_variable_list_sp(), m_variable_list_value_objects(),
m_recognized_frame_sp(), m_disassembly(), m_mutex() {
if (sc_ptr != nullptr) {
m_sc = *sc_ptr;
m_flags.Set(m_sc.GetResolvedMask());
}
if (reg_context_sp && !m_sc.target_sp) {
m_sc.target_sp = reg_context_sp->CalculateTarget();
if (m_sc.target_sp)
m_flags.Set(eSymbolContextTarget);
}
}
StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
user_id_t unwind_frame_index,
const RegisterContextSP &reg_context_sp, addr_t cfa,
const Address &pc_addr, bool behaves_like_zeroth_frame,
const SymbolContext *sc_ptr)
: m_thread_wp(thread_sp), m_frame_index(frame_idx),
m_concrete_frame_index(unwind_frame_index),
m_reg_context_sp(reg_context_sp),
m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa,
nullptr),
m_frame_code_addr(pc_addr), m_sc(), m_flags(), m_frame_base(),
m_frame_base_error(), m_cfa_is_valid(true),
m_stack_frame_kind(StackFrame::Kind::Regular),
m_behaves_like_zeroth_frame(behaves_like_zeroth_frame),
m_variable_list_sp(), m_variable_list_value_objects(),
m_recognized_frame_sp(), m_disassembly(), m_mutex() {
if (sc_ptr != nullptr) {
m_sc = *sc_ptr;
m_flags.Set(m_sc.GetResolvedMask());
}
if (!m_sc.target_sp && reg_context_sp) {
m_sc.target_sp = reg_context_sp->CalculateTarget();
if (m_sc.target_sp)
m_flags.Set(eSymbolContextTarget);
}
ModuleSP pc_module_sp(pc_addr.GetModule());
if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp) {
if (pc_module_sp) {
m_sc.module_sp = pc_module_sp;
m_flags.Set(eSymbolContextModule);
} else {
m_sc.module_sp.reset();
}
}
}
StackFrame::~StackFrame() = default;
StackID &StackFrame::GetStackID() {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
// Make sure we have resolved the StackID object's symbol context scope if we
// already haven't looked it up.
if (m_flags.IsClear(RESOLVED_FRAME_ID_SYMBOL_SCOPE)) {
if (m_id.GetSymbolContextScope()) {
// We already have a symbol context scope, we just don't have our flag
// bit set.
m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
} else {
// Calculate the frame block and use this for the stack ID symbol context
// scope if we have one.
SymbolContextScope *scope = GetFrameBlock();
if (scope == nullptr) {
// We don't have a block, so use the symbol
if (m_flags.IsClear(eSymbolContextSymbol))
GetSymbolContext(eSymbolContextSymbol);
// It is ok if m_sc.symbol is nullptr here
scope = m_sc.symbol;
}
// Set the symbol context scope (the accessor will set the
// RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags).
SetSymbolContextScope(scope);
}
}
return m_id;
}
uint32_t StackFrame::GetFrameIndex() const {
ThreadSP thread_sp = GetThread();
if (thread_sp)
return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
m_frame_index);
else
return m_frame_index;
}
void StackFrame::SetSymbolContextScope(SymbolContextScope *symbol_scope) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
m_flags.Set(RESOLVED_FRAME_ID_SYMBOL_SCOPE);
m_id.SetSymbolContextScope(symbol_scope);
}
const Address &StackFrame::GetFrameCodeAddress() {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) &&
!m_frame_code_addr.IsSectionOffset()) {
m_flags.Set(RESOLVED_FRAME_CODE_ADDR);
// Resolve the PC into a temporary address because if ResolveLoadAddress
// fails to resolve the address, it will clear the address object...
ThreadSP thread_sp(GetThread());
if (thread_sp) {
TargetSP target_sp(thread_sp->CalculateTarget());
if (target_sp) {
const bool allow_section_end = true;
if (m_frame_code_addr.SetOpcodeLoadAddress(
m_frame_code_addr.GetOffset(), target_sp.get(),
AddressClass::eCode, allow_section_end)) {
ModuleSP module_sp(m_frame_code_addr.GetModule());
if (module_sp) {
m_sc.module_sp = module_sp;
m_flags.Set(eSymbolContextModule);
}
}
}
}
}
return m_frame_code_addr;
}
bool StackFrame::ChangePC(addr_t pc) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
// We can't change the pc value of a history stack frame - it is immutable.
if (IsHistorical())
return false;
m_frame_code_addr.SetRawAddress(pc);
m_sc.Clear(false);
m_flags.Reset(0);
ThreadSP thread_sp(GetThread());
if (thread_sp)
thread_sp->ClearStackFrames();
return true;
}
const char *StackFrame::Disassemble() {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (m_disassembly.Empty()) {
ExecutionContext exe_ctx(shared_from_this());
Target *target = exe_ctx.GetTargetPtr();
if (target) {
const char *plugin_name = nullptr;
const char *flavor = nullptr;
Disassembler::Disassemble(target->GetDebugger(),
target->GetArchitecture(), plugin_name, flavor,
exe_ctx, 0, false, 0, 0, m_disassembly);
}
if (m_disassembly.Empty())
return nullptr;
}
return m_disassembly.GetData();
}
Block *StackFrame::GetFrameBlock() {
if (m_sc.block == nullptr && m_flags.IsClear(eSymbolContextBlock))
GetSymbolContext(eSymbolContextBlock);
if (m_sc.block) {
Block *inline_block = m_sc.block->GetContainingInlinedBlock();
if (inline_block) {
// Use the block with the inlined function info as the frame block we
// want this frame to have only the variables for the inlined function
// and its non-inlined block child blocks.
return inline_block;
} else {
// This block is not contained within any inlined function blocks with so
// we want to use the top most function block.
return &m_sc.function->GetBlock(false);
}
}
return nullptr;
}
// Get the symbol context if we already haven't done so by resolving the
// PC address as much as possible. This way when we pass around a
// StackFrame object, everyone will have as much information as possible and no
// one will ever have to look things up manually.
const SymbolContext &
StackFrame::GetSymbolContext(SymbolContextItem resolve_scope) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
// Copy our internal symbol context into "sc".
if ((m_flags.Get() & resolve_scope) != resolve_scope) {
uint32_t resolved = 0;
// If the target was requested add that:
if (!m_sc.target_sp) {
m_sc.target_sp = CalculateTarget();
if (m_sc.target_sp)
resolved |= eSymbolContextTarget;
}
// Resolve our PC to section offset if we haven't already done so and if we
// don't have a module. The resolved address section will contain the
// module to which it belongs
if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
GetFrameCodeAddress();
// If this is not frame zero, then we need to subtract 1 from the PC value
// when doing address lookups since the PC will be on the instruction
// following the function call instruction...
Address lookup_addr(GetFrameCodeAddress());
if (!m_behaves_like_zeroth_frame && lookup_addr.IsValid()) {
addr_t offset = lookup_addr.GetOffset();
if (offset > 0) {
lookup_addr.SetOffset(offset - 1);
} else {
// lookup_addr is the start of a section. We need do the math on the
// actual load address and re-compute the section. We're working with
// a 'noreturn' function at the end of a section.
ThreadSP thread_sp(GetThread());
if (thread_sp) {
TargetSP target_sp(thread_sp->CalculateTarget());
if (target_sp) {
addr_t addr_minus_one =
lookup_addr.GetLoadAddress(target_sp.get()) - 1;
lookup_addr.SetLoadAddress(addr_minus_one, target_sp.get());
} else {
lookup_addr.SetOffset(offset - 1);
}
}
}
}
if (m_sc.module_sp) {
// We have something in our stack frame symbol context, lets check if we
// haven't already tried to lookup one of those things. If we haven't
// then we will do the query.
SymbolContextItem actual_resolve_scope = SymbolContextItem(0);
if (resolve_scope & eSymbolContextCompUnit) {
if (m_flags.IsClear(eSymbolContextCompUnit)) {
if (m_sc.comp_unit)
resolved |= eSymbolContextCompUnit;
else
actual_resolve_scope |= eSymbolContextCompUnit;
}
}
if (resolve_scope & eSymbolContextFunction) {
if (m_flags.IsClear(eSymbolContextFunction)) {
if (m_sc.function)
resolved |= eSymbolContextFunction;
else
actual_resolve_scope |= eSymbolContextFunction;
}
}
if (resolve_scope & eSymbolContextBlock) {
if (m_flags.IsClear(eSymbolContextBlock)) {
if (m_sc.block)
resolved |= eSymbolContextBlock;
else
actual_resolve_scope |= eSymbolContextBlock;
}
}
if (resolve_scope & eSymbolContextSymbol) {
if (m_flags.IsClear(eSymbolContextSymbol)) {
if (m_sc.symbol)
resolved |= eSymbolContextSymbol;
else
actual_resolve_scope |= eSymbolContextSymbol;
}
}
if (resolve_scope & eSymbolContextLineEntry) {
if (m_flags.IsClear(eSymbolContextLineEntry)) {
if (m_sc.line_entry.IsValid())
resolved |= eSymbolContextLineEntry;
else
actual_resolve_scope |= eSymbolContextLineEntry;
}
}
if (actual_resolve_scope) {
// We might be resolving less information than what is already in our
// current symbol context so resolve into a temporary symbol context
// "sc" so we don't clear out data we have already found in "m_sc"
SymbolContext sc;
// Set flags that indicate what we have tried to resolve
resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
lookup_addr, actual_resolve_scope, sc);
// Only replace what we didn't already have as we may have information
// for an inlined function scope that won't match what a standard
// lookup by address would match
if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
m_sc.comp_unit = sc.comp_unit;
if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
m_sc.function = sc.function;
if ((resolved & eSymbolContextBlock) && m_sc.block == nullptr)
m_sc.block = sc.block;
if ((resolved & eSymbolContextSymbol) && m_sc.symbol == nullptr)
m_sc.symbol = sc.symbol;
if ((resolved & eSymbolContextLineEntry) &&
!m_sc.line_entry.IsValid()) {
m_sc.line_entry = sc.line_entry;
m_sc.line_entry.ApplyFileMappings(m_sc.target_sp);
}
}
} else {
// If we don't have a module, then we can't have the compile unit,
// function, block, line entry or symbol, so we can safely call
// ResolveSymbolContextForAddress with our symbol context member m_sc.
if (m_sc.target_sp) {
resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
lookup_addr, resolve_scope, m_sc);
}
}
// Update our internal flags so we remember what we have tried to locate so
// we don't have to keep trying when more calls to this function are made.
// We might have dug up more information that was requested (for example if
// we were asked to only get the block, we will have gotten the compile
// unit, and function) so set any additional bits that we resolved
m_flags.Set(resolve_scope | resolved);
}
// Return the symbol context with everything that was possible to resolve
// resolved.
return m_sc;
}
VariableList *StackFrame::GetVariableList(bool get_file_globals) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (m_flags.IsClear(RESOLVED_VARIABLES)) {
m_flags.Set(RESOLVED_VARIABLES);
Block *frame_block = GetFrameBlock();
if (frame_block) {
const bool get_child_variables = true;
const bool can_create = true;
const bool stop_if_child_block_is_inlined_function = true;
m_variable_list_sp = std::make_shared<VariableList>();
frame_block->AppendBlockVariables(can_create, get_child_variables,
stop_if_child_block_is_inlined_function,
[](Variable *v) { return true; },
m_variable_list_sp.get());
}
}
if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
m_flags.Set(RESOLVED_GLOBAL_VARIABLES);
if (m_flags.IsClear(eSymbolContextCompUnit))
GetSymbolContext(eSymbolContextCompUnit);
if (m_sc.comp_unit) {
VariableListSP global_variable_list_sp(
m_sc.comp_unit->GetVariableList(true));
if (m_variable_list_sp)
m_variable_list_sp->AddVariables(global_variable_list_sp.get());
else
m_variable_list_sp = global_variable_list_sp;
}
}
return m_variable_list_sp.get();
}
VariableListSP
StackFrame::GetInScopeVariableList(bool get_file_globals,
bool must_have_valid_location) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
// We can't fetch variable information for a history stack frame.
if (IsHistorical())
return VariableListSP();
VariableListSP var_list_sp(new VariableList);
GetSymbolContext(eSymbolContextCompUnit | eSymbolContextBlock);
if (m_sc.block) {
const bool can_create = true;
const bool get_parent_variables = true;
const bool stop_if_block_is_inlined_function = true;
m_sc.block->AppendVariables(
can_create, get_parent_variables, stop_if_block_is_inlined_function,
[this, must_have_valid_location](Variable *v) {
return v->IsInScope(this) && (!must_have_valid_location ||
v->LocationIsValidForFrame(this));
},
var_list_sp.get());
}
if (m_sc.comp_unit && get_file_globals) {
VariableListSP global_variable_list_sp(
m_sc.comp_unit->GetVariableList(true));
if (global_variable_list_sp)
var_list_sp->AddVariables(global_variable_list_sp.get());
}
return var_list_sp;
}
ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
llvm::StringRef var_expr, DynamicValueType use_dynamic, uint32_t options,
VariableSP &var_sp, Status &error) {
llvm::StringRef original_var_expr = var_expr;
// We can't fetch variable information for a history stack frame.
if (IsHistorical())
return ValueObjectSP();
if (var_expr.empty()) {
error.SetErrorStringWithFormat("invalid variable path '%s'",
var_expr.str().c_str());
return ValueObjectSP();
}
const bool check_ptr_vs_member =
(options & eExpressionPathOptionCheckPtrVsMember) != 0;
const bool no_fragile_ivar =
(options & eExpressionPathOptionsNoFragileObjcIvar) != 0;
const bool no_synth_child =
(options & eExpressionPathOptionsNoSyntheticChildren) != 0;
// const bool no_synth_array = (options &
// eExpressionPathOptionsNoSyntheticArrayRange) != 0;
error.Clear();
bool deref = false;
bool address_of = false;
ValueObjectSP valobj_sp;
const bool get_file_globals = true;
// When looking up a variable for an expression, we need only consider the
// variables that are in scope.
VariableListSP var_list_sp(GetInScopeVariableList(get_file_globals));
VariableList *variable_list = var_list_sp.get();
if (!variable_list)
return ValueObjectSP();
// If first character is a '*', then show pointer contents
std::string var_expr_storage;
if (var_expr[0] == '*') {
deref = true;
var_expr = var_expr.drop_front(); // Skip the '*'
} else if (var_expr[0] == '&') {
address_of = true;
var_expr = var_expr.drop_front(); // Skip the '&'
}
size_t separator_idx = var_expr.find_first_of(".-[=+~|&^%#@!/?,<>{}");
StreamString var_expr_path_strm;
ConstString name_const_string(var_expr.substr(0, separator_idx));
var_sp = variable_list->FindVariable(name_const_string, false);
bool synthetically_added_instance_object = false;
if (var_sp) {
var_expr = var_expr.drop_front(name_const_string.GetLength());
}
if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
// Check for direct ivars access which helps us with implicit access to
// ivars with the "this->" or "self->"
GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock);
lldb::LanguageType method_language = eLanguageTypeUnknown;
bool is_instance_method = false;
ConstString method_object_name;
if (m_sc.GetFunctionMethodInfo(method_language, is_instance_method,
method_object_name)) {
if (is_instance_method && method_object_name) {
var_sp = variable_list->FindVariable(method_object_name);
if (var_sp) {
separator_idx = 0;
var_expr_storage = "->";
var_expr_storage += var_expr;
var_expr = var_expr_storage;
synthetically_added_instance_object = true;
}
}
}
}
if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
// Check if any anonymous unions are there which contain a variable with
// the name we need
for (const VariableSP &variable_sp : *variable_list) {
if (!variable_sp)
continue;
if (!variable_sp->GetName().IsEmpty())
continue;
Type *var_type = variable_sp->GetType();
if (!var_type)
continue;
if (!var_type->GetForwardCompilerType().IsAnonymousType())
continue;
valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
if (!valobj_sp)
return valobj_sp;
valobj_sp = valobj_sp->GetChildMemberWithName(name_const_string, true);
if (valobj_sp)
break;
}
}
if (var_sp && !valobj_sp) {
valobj_sp = GetValueObjectForFrameVariable(var_sp, use_dynamic);
if (!valobj_sp)
return valobj_sp;
}
if (!valobj_sp) {
error.SetErrorStringWithFormat("no variable named '%s' found in this frame",
name_const_string.GetCString());
return ValueObjectSP();
}
// We are dumping at least one child
while (separator_idx != std::string::npos) {
// Calculate the next separator index ahead of time
ValueObjectSP child_valobj_sp;
const char separator_type = var_expr[0];
bool expr_is_ptr = false;
switch (separator_type) {
case '-':
expr_is_ptr = true;
if (var_expr.size() >= 2 && var_expr[1] != '>')
return ValueObjectSP();
if (no_fragile_ivar) {
// Make sure we aren't trying to deref an objective
// C ivar if this is not allowed
const uint32_t pointer_type_flags =
valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
if ((pointer_type_flags & eTypeIsObjC) &&
(pointer_type_flags & eTypeIsPointer)) {
// This was an objective C object pointer and it was requested we
// skip any fragile ivars so return nothing here
return ValueObjectSP();
}
}
// If we have a non pointer type with a sythetic value then lets check if
// we have an sythetic dereference specified.
if (!valobj_sp->IsPointerType() && valobj_sp->HasSyntheticValue()) {
Status deref_error;
if (valobj_sp->GetCompilerType().IsReferenceType()) {
valobj_sp = valobj_sp->GetSyntheticValue()->Dereference(deref_error);
if (error.Fail()) {
error.SetErrorStringWithFormatv(
"Failed to dereference reference type: %s", deref_error);
return ValueObjectSP();
}
}
valobj_sp = valobj_sp->Dereference(deref_error);
if (error.Fail()) {
error.SetErrorStringWithFormatv(
"Failed to dereference sythetic value: {0}", deref_error);
return ValueObjectSP();
}
// Some synthetic plug-ins fail to set the error in Dereference
if (!valobj_sp) {
error.SetErrorString("Failed to dereference sythetic value");
return ValueObjectSP();
}
expr_is_ptr = false;
}
var_expr = var_expr.drop_front(); // Remove the '-'
LLVM_FALLTHROUGH;
case '.': {
var_expr = var_expr.drop_front(); // Remove the '.' or '>'
separator_idx = var_expr.find_first_of(".-[");
ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));
if (check_ptr_vs_member) {
// We either have a pointer type and need to verify valobj_sp is a
// pointer, or we have a member of a class/union/struct being accessed
// with the . syntax and need to verify we don't have a pointer.
const bool actual_is_ptr = valobj_sp->IsPointerType();
if (actual_is_ptr != expr_is_ptr) {
// Incorrect use of "." with a pointer, or "->" with a
// class/union/struct instance or reference.
valobj_sp->GetExpressionPath(var_expr_path_strm);
if (actual_is_ptr)
error.SetErrorStringWithFormat(
"\"%s\" is a pointer and . was used to attempt to access "
"\"%s\". Did you mean \"%s->%s\"?",
var_expr_path_strm.GetData(), child_name.GetCString(),
var_expr_path_strm.GetData(), var_expr.str().c_str());
else
error.SetErrorStringWithFormat(
"\"%s\" is not a pointer and -> was used to attempt to "
"access \"%s\". Did you mean \"%s.%s\"?",
var_expr_path_strm.GetData(), child_name.GetCString(),
var_expr_path_strm.GetData(), var_expr.str().c_str());
return ValueObjectSP();
}
}
child_valobj_sp = valobj_sp->GetChildMemberWithName(child_name, true);
if (!child_valobj_sp) {
if (!no_synth_child) {
child_valobj_sp = valobj_sp->GetSyntheticValue();
if (child_valobj_sp)
child_valobj_sp =
child_valobj_sp->GetChildMemberWithName(child_name, true);
}
if (no_synth_child || !child_valobj_sp) {
// No child member with name "child_name"
if (synthetically_added_instance_object) {
// We added a "this->" or "self->" to the beginning of the
// expression and this is the first pointer ivar access, so just
// return the normal error
error.SetErrorStringWithFormat(
"no variable or instance variable named '%s' found in "
"this frame",
name_const_string.GetCString());
} else {
valobj_sp->GetExpressionPath(var_expr_path_strm);
if (child_name) {
error.SetErrorStringWithFormat(
"\"%s\" is not a member of \"(%s) %s\"",
child_name.GetCString(),
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
} else {
error.SetErrorStringWithFormat(
"incomplete expression path after \"%s\" in \"%s\"",
var_expr_path_strm.GetData(),
original_var_expr.str().c_str());
}
}
return ValueObjectSP();
}
}
synthetically_added_instance_object = false;
// Remove the child name from the path
var_expr = var_expr.drop_front(child_name.GetLength());
if (use_dynamic != eNoDynamicValues) {
ValueObjectSP dynamic_value_sp(
child_valobj_sp->GetDynamicValue(use_dynamic));
if (dynamic_value_sp)
child_valobj_sp = dynamic_value_sp;
}
} break;
case '[': {
// Array member access, or treating pointer as an array Need at least two
// brackets and a number
if (var_expr.size() <= 2) {
error.SetErrorStringWithFormat(
"invalid square bracket encountered after \"%s\" in \"%s\"",
var_expr_path_strm.GetData(), var_expr.str().c_str());
return ValueObjectSP();
}
// Drop the open brace.
var_expr = var_expr.drop_front();
long child_index = 0;
// If there's no closing brace, this is an invalid expression.
size_t end_pos = var_expr.find_first_of(']');
if (end_pos == llvm::StringRef::npos) {
error.SetErrorStringWithFormat(
"missing closing square bracket in expression \"%s\"",
var_expr_path_strm.GetData());
return ValueObjectSP();
}
llvm::StringRef index_expr = var_expr.take_front(end_pos);
llvm::StringRef original_index_expr = index_expr;
// Drop all of "[index_expr]"
var_expr = var_expr.drop_front(end_pos + 1);
if (index_expr.consumeInteger(0, child_index)) {
// If there was no integer anywhere in the index expression, this is
// erroneous expression.
error.SetErrorStringWithFormat("invalid index expression \"%s\"",
index_expr.str().c_str());
return ValueObjectSP();
}
if (index_expr.empty()) {
// The entire index expression was a single integer.
if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
// what we have is *ptr[low]. the most similar C++ syntax is to deref
// ptr and extract bit low out of it. reading array item low would be
// done by saying ptr[low], without a deref * sign
Status error;
ValueObjectSP temp(valobj_sp->Dereference(error));
if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"could not dereference \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return ValueObjectSP();
}
valobj_sp = temp;
deref = false;
} else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
deref) {
// what we have is *arr[low]. the most similar C++ syntax is to get
// arr[0] (an operation that is equivalent to deref-ing arr) and
// extract bit low out of it. reading array item low would be done by
// saying arr[low], without a deref * sign
Status error;
ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"could not get item 0 for \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return ValueObjectSP();
}
valobj_sp = temp;
deref = false;
}
bool is_incomplete_array = false;
if (valobj_sp->IsPointerType()) {
bool is_objc_pointer = true;
if (valobj_sp->GetCompilerType().GetMinimumLanguage() !=
eLanguageTypeObjC)
is_objc_pointer = false;
else if (!valobj_sp->GetCompilerType().IsPointerType())
is_objc_pointer = false;
if (no_synth_child && is_objc_pointer) {
error.SetErrorStringWithFormat(
"\"(%s) %s\" is an Objective-C pointer, and cannot be "
"subscripted",
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return ValueObjectSP();
} else if (is_objc_pointer) {
// dereferencing ObjC variables is not valid.. so let's try and
// recur to synthetic children
ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
if (!synthetic /* no synthetic */
|| synthetic == valobj_sp) /* synthetic is the same as
the original object */
{
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"\"(%s) %s\" is not an array type",
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
} else if (
static_cast<uint32_t>(child_index) >=
synthetic
->GetNumChildren() /* synthetic does not have that many values */) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
} else {
child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
}
}
} else {
child_valobj_sp =
valobj_sp->GetSyntheticArrayMember(child_index, true);
if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"failed to use pointer as array for index %ld for "
"\"(%s) %s\"",
child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
}
}
} else if (valobj_sp->GetCompilerType().IsArrayType(
nullptr, nullptr, &is_incomplete_array)) {
// Pass false to dynamic_value here so we can tell the difference
// between no dynamic value and no member of this type...
child_valobj_sp = valobj_sp->GetChildAtIndex(child_index, true);
if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
child_valobj_sp =
valobj_sp->GetSyntheticArrayMember(child_index, true);
if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
}
} else if (valobj_sp->GetCompilerType().IsScalarType()) {
// this is a bitfield asking to display just one bit
child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
child_index, child_index, true);
if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"bitfield range %ld-%ld is not valid for \"(%s) %s\"",
child_index, child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
}
} else {
ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
if (no_synth_child /* synthetic is forbidden */ ||
!synthetic /* no synthetic */
|| synthetic == valobj_sp) /* synthetic is the same as the
original object */
{
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"\"(%s) %s\" is not an array type",
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
} else if (
static_cast<uint32_t>(child_index) >=
synthetic
->GetNumChildren() /* synthetic does not have that many values */) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
} else {
child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
}
}
}
if (!child_valobj_sp) {
// Invalid array index...
return ValueObjectSP();
}
separator_idx = var_expr.find_first_of(".-[");
if (use_dynamic != eNoDynamicValues) {
ValueObjectSP dynamic_value_sp(
child_valobj_sp->GetDynamicValue(use_dynamic));
if (dynamic_value_sp)
child_valobj_sp = dynamic_value_sp;
}
// Break out early from the switch since we were able to find the child
// member
break;
}
// this is most probably a BitField, let's take a look
if (index_expr.front() != '-') {
error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
original_index_expr.str().c_str());
return ValueObjectSP();
}
index_expr = index_expr.drop_front();
long final_index = 0;
if (index_expr.getAsInteger(0, final_index)) {
error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
original_index_expr.str().c_str());
return ValueObjectSP();
}
// if the format given is [high-low], swap range
if (child_index > final_index) {
long temp = child_index;
child_index = final_index;
final_index = temp;
}
if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
// what we have is *ptr[low-high]. the most similar C++ syntax is to
// deref ptr and extract bits low thru high out of it. reading array
// items low thru high would be done by saying ptr[low-high], without a
// deref * sign
Status error;
ValueObjectSP temp(valobj_sp->Dereference(error));
if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"could not dereference \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return ValueObjectSP();
}
valobj_sp = temp;
deref = false;
} else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref) {
// what we have is *arr[low-high]. the most similar C++ syntax is to
// get arr[0] (an operation that is equivalent to deref-ing arr) and
// extract bits low thru high out of it. reading array items low thru
// high would be done by saying arr[low-high], without a deref * sign
Status error;
ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"could not get item 0 for \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return ValueObjectSP();
}
valobj_sp = temp;
deref = false;
}
child_valobj_sp =
valobj_sp->GetSyntheticBitFieldChild(child_index, final_index, true);
if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"bitfield range %ld-%ld is not valid for \"(%s) %s\"", child_index,
final_index, valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
}
if (!child_valobj_sp) {
// Invalid bitfield range...
return ValueObjectSP();
}
separator_idx = var_expr.find_first_of(".-[");
if (use_dynamic != eNoDynamicValues) {
ValueObjectSP dynamic_value_sp(
child_valobj_sp->GetDynamicValue(use_dynamic));
if (dynamic_value_sp)
child_valobj_sp = dynamic_value_sp;
}
// Break out early from the switch since we were able to find the child
// member
break;
}
default:
// Failure...
{
valobj_sp->GetExpressionPath(var_expr_path_strm);
error.SetErrorStringWithFormat(
"unexpected char '%c' encountered after \"%s\" in \"%s\"",
separator_type, var_expr_path_strm.GetData(),
var_expr.str().c_str());
return ValueObjectSP();
}
}
if (child_valobj_sp)
valobj_sp = child_valobj_sp;
if (var_expr.empty())
break;
}
if (valobj_sp) {
if (deref) {
ValueObjectSP deref_valobj_sp(valobj_sp->Dereference(error));
valobj_sp = deref_valobj_sp;
} else if (address_of) {
ValueObjectSP address_of_valobj_sp(valobj_sp->AddressOf(error));
valobj_sp = address_of_valobj_sp;
}
}
return valobj_sp;
}
bool StackFrame::GetFrameBaseValue(Scalar &frame_base, Status *error_ptr) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (!m_cfa_is_valid) {
m_frame_base_error.SetErrorString(
"No frame base available for this historical stack frame.");
return false;
}
if (m_flags.IsClear(GOT_FRAME_BASE)) {
if (m_sc.function) {
m_frame_base.Clear();
m_frame_base_error.Clear();
m_flags.Set(GOT_FRAME_BASE);
ExecutionContext exe_ctx(shared_from_this());
Value expr_value;
addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
if (m_sc.function->GetFrameBaseExpression().IsLocationList())
loclist_base_addr =
m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
exe_ctx.GetTargetPtr());
if (!m_sc.function->GetFrameBaseExpression().Evaluate(
&exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr,
expr_value, &m_frame_base_error)) {
// We should really have an error if evaluate returns, but in case we
// don't, lets set the error to something at least.
if (m_frame_base_error.Success())
m_frame_base_error.SetErrorString(
"Evaluation of the frame base expression failed.");
} else {
m_frame_base = expr_value.ResolveValue(&exe_ctx);
}
} else {
m_frame_base_error.SetErrorString("No function in symbol context.");
}
}
if (m_frame_base_error.Success())
frame_base = m_frame_base;
if (error_ptr)
*error_ptr = m_frame_base_error;
return m_frame_base_error.Success();
}
DWARFExpression *StackFrame::GetFrameBaseExpression(Status *error_ptr) {
if (!m_sc.function) {
if (error_ptr) {
error_ptr->SetErrorString("No function in symbol context.");
}
return nullptr;
}
return &m_sc.function->GetFrameBaseExpression();
}
RegisterContextSP StackFrame::GetRegisterContext() {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (!m_reg_context_sp) {
ThreadSP thread_sp(GetThread());
if (thread_sp)
m_reg_context_sp = thread_sp->CreateRegisterContextForFrame(this);
}
return m_reg_context_sp;
}
bool StackFrame::HasDebugInformation() {
GetSymbolContext(eSymbolContextLineEntry);
return m_sc.line_entry.IsValid();
}
ValueObjectSP
StackFrame::GetValueObjectForFrameVariable(const VariableSP &variable_sp,
DynamicValueType use_dynamic) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
ValueObjectSP valobj_sp;
if (IsHistorical()) {
return valobj_sp;
}
VariableList *var_list = GetVariableList(true);
if (var_list) {
// Make sure the variable is a frame variable
const uint32_t var_idx = var_list->FindIndexForVariable(variable_sp.get());
const uint32_t num_variables = var_list->GetSize();
if (var_idx < num_variables) {
valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex(var_idx);
if (!valobj_sp) {
if (m_variable_list_value_objects.GetSize() < num_variables)
m_variable_list_value_objects.Resize(num_variables);
valobj_sp = ValueObjectVariable::Create(this, variable_sp);
m_variable_list_value_objects.SetValueObjectAtIndex(var_idx, valobj_sp);
}
}
}
if (use_dynamic != eNoDynamicValues && valobj_sp) {
ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue(use_dynamic);
if (dynamic_sp)
return dynamic_sp;
}
return valobj_sp;
}
ValueObjectSP StackFrame::TrackGlobalVariable(const VariableSP &variable_sp,
DynamicValueType use_dynamic) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (IsHistorical())
return ValueObjectSP();
// Check to make sure we aren't already tracking this variable?
ValueObjectSP valobj_sp(
GetValueObjectForFrameVariable(variable_sp, use_dynamic));
if (!valobj_sp) {
// We aren't already tracking this global
VariableList *var_list = GetVariableList(true);
// If this frame has no variables, create a new list
if (var_list == nullptr)
m_variable_list_sp = std::make_shared<VariableList>();
// Add the global/static variable to this frame
m_variable_list_sp->AddVariable(variable_sp);
// Now make a value object for it so we can track its changes
valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
}
return valobj_sp;
}
bool StackFrame::IsInlined() {
if (m_sc.block == nullptr)
GetSymbolContext(eSymbolContextBlock);
if (m_sc.block)
return m_sc.block->GetContainingInlinedBlock() != nullptr;
return false;
}
bool StackFrame::IsHistorical() const {
return m_stack_frame_kind == StackFrame::Kind::History;
}
bool StackFrame::IsArtificial() const {
return m_stack_frame_kind == StackFrame::Kind::Artificial;
}
lldb::LanguageType StackFrame::GetLanguage() {
CompileUnit *cu = GetSymbolContext(eSymbolContextCompUnit).comp_unit;
if (cu)
return cu->GetLanguage();
return lldb::eLanguageTypeUnknown;
}
lldb::LanguageType StackFrame::GuessLanguage() {
LanguageType lang_type = GetLanguage();
if (lang_type == eLanguageTypeUnknown) {
SymbolContext sc = GetSymbolContext(eSymbolContextFunction
| eSymbolContextSymbol);
if (sc.function) {
lang_type = sc.function->GetMangled().GuessLanguage();
}
else if (sc.symbol)
{
lang_type = sc.symbol->GetMangled().GuessLanguage();
}
}
return lang_type;
}
namespace {
std::pair<const Instruction::Operand *, int64_t>
GetBaseExplainingValue(const Instruction::Operand &operand,
RegisterContext &register_context, lldb::addr_t value) {
switch (operand.m_type) {
case Instruction::Operand::Type::Dereference:
case Instruction::Operand::Type::Immediate:
case Instruction::Operand::Type::Invalid:
case Instruction::Operand::Type::Product:
// These are not currently interesting
return std::make_pair(nullptr, 0);
case Instruction::Operand::Type::Sum: {
const Instruction::Operand *immediate_child = nullptr;
const Instruction::Operand *variable_child = nullptr;
if (operand.m_children[0].m_type == Instruction::Operand::Type::Immediate) {
immediate_child = &operand.m_children[0];
variable_child = &operand.m_children[1];
} else if (operand.m_children[1].m_type ==
Instruction::Operand::Type::Immediate) {
immediate_child = &operand.m_children[1];
variable_child = &operand.m_children[0];
}
if (!immediate_child) {
return std::make_pair(nullptr, 0);
}
lldb::addr_t adjusted_value = value;
if (immediate_child->m_negative) {
adjusted_value += immediate_child->m_immediate;
} else {
adjusted_value -= immediate_child->m_immediate;
}
std::pair<const Instruction::Operand *, int64_t> base_and_offset =
GetBaseExplainingValue(*variable_child, register_context,
adjusted_value);
if (!base_and_offset.first) {
return std::make_pair(nullptr, 0);
}
if (immediate_child->m_negative) {
base_and_offset.second -= immediate_child->m_immediate;
} else {
base_and_offset.second += immediate_child->m_immediate;
}
return base_and_offset;
}
case Instruction::Operand::Type::Register: {
const RegisterInfo *info =
register_context.GetRegisterInfoByName(operand.m_register.AsCString());
if (!info) {
return std::make_pair(nullptr, 0);
}
RegisterValue reg_value;
if (!register_context.ReadRegister(info, reg_value)) {
return std::make_pair(nullptr, 0);
}
if (reg_value.GetAsUInt64() == value) {
return std::make_pair(&operand, 0);
} else {
return std::make_pair(nullptr, 0);
}
}
}
return std::make_pair(nullptr, 0);
}
std::pair<const Instruction::Operand *, int64_t>
GetBaseExplainingDereference(const Instruction::Operand &operand,
RegisterContext &register_context,
lldb::addr_t addr) {
if (operand.m_type == Instruction::Operand::Type::Dereference) {
return GetBaseExplainingValue(operand.m_children[0], register_context,
addr);
}
return std::make_pair(nullptr, 0);
}
}
lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
TargetSP target_sp = CalculateTarget();
const ArchSpec &target_arch = target_sp->GetArchitecture();
AddressRange pc_range;
pc_range.GetBaseAddress() = GetFrameCodeAddress();
pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
const char *plugin_name = nullptr;
const char *flavor = nullptr;
const bool prefer_file_cache = false;
DisassemblerSP disassembler_sp =
Disassembler::DisassembleRange(target_arch, plugin_name, flavor,
*target_sp, pc_range, prefer_file_cache);
if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
return ValueObjectSP();
}
InstructionSP instruction_sp =
disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
llvm::SmallVector<Instruction::Operand, 3> operands;
if (!instruction_sp->ParseOperands(operands)) {
return ValueObjectSP();
}
RegisterContextSP register_context_sp = GetRegisterContext();
if (!register_context_sp) {
return ValueObjectSP();
}
for (const Instruction::Operand &operand : operands) {
std::pair<const Instruction::Operand *, int64_t> base_and_offset =
GetBaseExplainingDereference(operand, *register_context_sp, addr);
if (!base_and_offset.first) {
continue;
}
switch (base_and_offset.first->m_type) {
case Instruction::Operand::Type::Immediate: {
lldb_private::Address addr;
if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
base_and_offset.second,
addr)) {
auto c_type_system_or_err =
target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
if (auto err = c_type_system_or_err.takeError()) {
LLDB_LOG_ERROR(
lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD),
std::move(err), "Unable to guess value for given address");
return ValueObjectSP();
} else {
CompilerType void_ptr_type =
c_type_system_or_err
->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
.GetPointerType();
return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
}
} else {
return ValueObjectSP();
}
break;
}
case Instruction::Operand::Type::Register: {
return GuessValueForRegisterAndOffset(base_and_offset.first->m_register,
base_and_offset.second);
}
default:
return ValueObjectSP();
}
}
return ValueObjectSP();
}
namespace {
ValueObjectSP GetValueForOffset(StackFrame &frame, ValueObjectSP &parent,
int64_t offset) {
if (offset < 0 || uint64_t(offset) >= parent->GetByteSize()) {
return ValueObjectSP();
}
if (parent->IsPointerOrReferenceType()) {
return parent;
}
for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci) {
const bool can_create = true;
ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
if (!child_sp) {
return ValueObjectSP();
}
int64_t child_offset = child_sp->GetByteOffset();
int64_t child_size = child_sp->GetByteSize();
if (offset >= child_offset && offset < (child_offset + child_size)) {
return GetValueForOffset(frame, child_sp, offset - child_offset);
}
}
if (offset == 0) {
return parent;
} else {
return ValueObjectSP();
}
}
ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
ValueObjectSP &base,
int64_t offset) {
// base is a pointer to something
// offset is the thing to add to the pointer We return the most sensible
// ValueObject for the result of *(base+offset)
if (!base->IsPointerOrReferenceType()) {
return ValueObjectSP();
}
Status error;
ValueObjectSP pointee = base->Dereference(error);
if (!pointee) {
return ValueObjectSP();
}
if (offset >= 0 && uint64_t(offset) >= pointee->GetByteSize()) {
int64_t index = offset / pointee->GetByteSize();
offset = offset % pointee->GetByteSize();
const bool can_create = true;
pointee = base->GetSyntheticArrayMember(index, can_create);
}
if (!pointee || error.Fail()) {
return ValueObjectSP();
}
return GetValueForOffset(frame, pointee, offset);
}
/// Attempt to reconstruct the ValueObject for the address contained in a
/// given register plus an offset.
///
/// \params [in] frame
/// The current stack frame.
///
/// \params [in] reg
/// The register.
///
/// \params [in] offset
/// The offset from the register.
///
/// \param [in] disassembler
/// A disassembler containing instructions valid up to the current PC.
///
/// \param [in] variables
/// The variable list from the current frame,
///
/// \param [in] pc
/// The program counter for the instruction considered the 'user'.
///
/// \return
/// A string describing the base for the ExpressionPath. This could be a
/// variable, a register value, an argument, or a function return value.
/// The ValueObject if found. If valid, it has a valid ExpressionPath.
lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
int64_t offset, Disassembler &disassembler,
VariableList &variables, const Address &pc) {
// Example of operation for Intel:
//
// +14: movq -0x8(%rbp), %rdi
// +18: movq 0x8(%rdi), %rdi
// +22: addl 0x4(%rdi), %eax
//
// f, a pointer to a struct, is known to be at -0x8(%rbp).
//
// DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at
// +18 that assigns to rdi, and calls itself recursively for that dereference
// DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
// +14 that assigns to rdi, and calls itself recursively for that
// derefernece
// DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the
// variable list.
// Returns a ValueObject for f. (That's what was stored at rbp-8 at +14)
// Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
// at +18)
// Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
// rdi+4 at +22)
// First, check the variable list to see if anything is at the specified
// location.
using namespace OperandMatchers;
const RegisterInfo *reg_info =
frame.GetRegisterContext()->GetRegisterInfoByName(reg.AsCString());
if (!reg_info) {
return ValueObjectSP();
}
Instruction::Operand op =
offset ? Instruction::Operand::BuildDereference(
Instruction::Operand::BuildSum(
Instruction::Operand::BuildRegister(reg),
Instruction::Operand::BuildImmediate(offset)))
: Instruction::Operand::BuildDereference(
Instruction::Operand::BuildRegister(reg));
for (VariableSP var_sp : variables) {
if (var_sp->LocationExpression().MatchesOperand(frame, op))
return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
}
const uint32_t current_inst =
disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(pc);
if (current_inst == UINT32_MAX) {
return ValueObjectSP();
}
for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {
// This is not an exact algorithm, and it sacrifices accuracy for
// generality. Recognizing "mov" and "ld" instructions –– and which
// are their source and destination operands -- is something the
// disassembler should do for us.
InstructionSP instruction_sp =
disassembler.GetInstructionList().GetInstructionAtIndex(ii);
if (instruction_sp->IsCall()) {
ABISP abi_sp = frame.CalculateProcess()->GetABI();
if (!abi_sp) {
continue;
}
const char *return_register_name;
if (!abi_sp->GetPointerReturnRegister(return_register_name)) {
continue;
}
const RegisterInfo *return_register_info =
frame.GetRegisterContext()->GetRegisterInfoByName(
return_register_name);
if (!return_register_info) {
continue;
}
int64_t offset = 0;
if (!MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference),
MatchRegOp(*return_register_info))(op) &&
!MatchUnaryOp(
MatchOpType(Instruction::Operand::Type::Dereference),
MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
MatchRegOp(*return_register_info),
FetchImmOp(offset)))(op)) {
continue;
}
llvm::SmallVector<Instruction::Operand, 1> operands;
if (!instruction_sp->ParseOperands(operands) || operands.size() != 1) {
continue;
}
switch (operands[0].m_type) {
default:
break;
case Instruction::Operand::Type::Immediate: {
SymbolContext sc;
Address load_address;
if (!frame.CalculateTarget()->ResolveLoadAddress(
operands[0].m_immediate, load_address)) {
break;
}
frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(
load_address, eSymbolContextFunction, sc);
if (!sc.function) {
break;
}
CompilerType function_type = sc.function->GetCompilerType();
if (!function_type.IsFunctionType()) {
break;
}
CompilerType return_type = function_type.GetFunctionReturnType();
RegisterValue return_value;
if (!frame.GetRegisterContext()->ReadRegister(return_register_info,
return_value)) {
break;
}
std::string name_str(
sc.function->GetName().AsCString("<unknown function>"));
name_str.append("()");
Address return_value_address(return_value.GetAsUInt64());
ValueObjectSP return_value_sp = ValueObjectMemory::Create(
&frame, name_str, return_value_address, return_type);
return GetValueForDereferincingOffset(frame, return_value_sp, offset);
}
}
continue;
}
llvm::SmallVector<Instruction::Operand, 2> operands;
if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
continue;
}
Instruction::Operand *origin_operand = nullptr;
auto clobbered_reg_matcher = [reg_info](const Instruction::Operand &op) {
return MatchRegOp(*reg_info)(op) && op.m_clobbered;
};
if (clobbered_reg_matcher(operands[0])) {
origin_operand = &operands[1];
}
else if (clobbered_reg_matcher(operands[1])) {
origin_operand = &operands[0];
}
else {
continue;
}
// We have an origin operand. Can we track its value down?
ValueObjectSP source_path;
ConstString origin_register;
int64_t origin_offset = 0;
if (FetchRegOp(origin_register)(*origin_operand)) {
source_path = DoGuessValueAt(frame, origin_register, 0, disassembler,
variables, instruction_sp->GetAddress());
} else if (MatchUnaryOp(
MatchOpType(Instruction::Operand::Type::Dereference),
FetchRegOp(origin_register))(*origin_operand) ||
MatchUnaryOp(
MatchOpType(Instruction::Operand::Type::Dereference),
MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
FetchRegOp(origin_register),
FetchImmOp(origin_offset)))(*origin_operand)) {
source_path =
DoGuessValueAt(frame, origin_register, origin_offset, disassembler,
variables, instruction_sp->GetAddress());
if (!source_path) {
continue;
}
source_path =
GetValueForDereferincingOffset(frame, source_path, offset);
}
if (source_path) {
return source_path;
}
}
return ValueObjectSP();
}
}
lldb::ValueObjectSP StackFrame::GuessValueForRegisterAndOffset(ConstString reg,
int64_t offset) {
TargetSP target_sp = CalculateTarget();
const ArchSpec &target_arch = target_sp->GetArchitecture();
Block *frame_block = GetFrameBlock();
if (!frame_block) {
return ValueObjectSP();
}
Function *function = frame_block->CalculateSymbolContextFunction();
if (!function) {
return ValueObjectSP();
}
AddressRange pc_range = function->GetAddressRange();
if (GetFrameCodeAddress().GetFileAddress() <
pc_range.GetBaseAddress().GetFileAddress() ||
GetFrameCodeAddress().GetFileAddress() -
pc_range.GetBaseAddress().GetFileAddress() >=
pc_range.GetByteSize()) {
return ValueObjectSP();
}
const char *plugin_name = nullptr;
const char *flavor = nullptr;
const bool prefer_file_cache = false;
DisassemblerSP disassembler_sp =
Disassembler::DisassembleRange(target_arch, plugin_name, flavor,
*target_sp, pc_range, prefer_file_cache);
if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
return ValueObjectSP();
}
const bool get_file_globals = false;
VariableList *variables = GetVariableList(get_file_globals);
if (!variables) {
return ValueObjectSP();
}
return DoGuessValueAt(*this, reg, offset, *disassembler_sp, *variables,
GetFrameCodeAddress());
}
lldb::ValueObjectSP StackFrame::FindVariable(ConstString name) {
ValueObjectSP value_sp;
if (!name)
return value_sp;
TargetSP target_sp = CalculateTarget();
ProcessSP process_sp = CalculateProcess();
if (!target_sp && !process_sp)
return value_sp;
VariableList variable_list;
VariableSP var_sp;
SymbolContext sc(GetSymbolContext(eSymbolContextBlock));
if (sc.block) {
const bool can_create = true;
const bool get_parent_variables = true;
const bool stop_if_block_is_inlined_function = true;
if (sc.block->AppendVariables(
can_create, get_parent_variables, stop_if_block_is_inlined_function,
[this](Variable *v) { return v->IsInScope(this); },
&variable_list)) {
var_sp = variable_list.FindVariable(name);
}
if (var_sp)
value_sp = GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
}
return value_sp;
}
TargetSP StackFrame::CalculateTarget() {
TargetSP target_sp;
ThreadSP thread_sp(GetThread());
if (thread_sp) {
ProcessSP process_sp(thread_sp->CalculateProcess());
if (process_sp)
target_sp = process_sp->CalculateTarget();
}
return target_sp;
}
ProcessSP StackFrame::CalculateProcess() {
ProcessSP process_sp;
ThreadSP thread_sp(GetThread());
if (thread_sp)
process_sp = thread_sp->CalculateProcess();
return process_sp;
}
ThreadSP StackFrame::CalculateThread() { return GetThread(); }
StackFrameSP StackFrame::CalculateStackFrame() { return shared_from_this(); }
void StackFrame::CalculateExecutionContext(ExecutionContext &exe_ctx) {
exe_ctx.SetContext(shared_from_this());
}
void StackFrame::DumpUsingSettingsFormat(Stream *strm, bool show_unique,
const char *frame_marker) {
if (strm == nullptr)
return;
GetSymbolContext(eSymbolContextEverything);
ExecutionContext exe_ctx(shared_from_this());
StreamString s;
if (frame_marker)
s.PutCString(frame_marker);
const FormatEntity::Entry *frame_format = nullptr;
Target *target = exe_ctx.GetTargetPtr();
if (target) {
if (show_unique) {
frame_format = target->GetDebugger().GetFrameFormatUnique();
} else {
frame_format = target->GetDebugger().GetFrameFormat();
}
}
if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx,
nullptr, nullptr, false, false)) {
strm->PutCString(s.GetString());
} else {
Dump(strm, true, false);
strm->EOL();
}
}
void StackFrame::Dump(Stream *strm, bool show_frame_index,
bool show_fullpaths) {
if (strm == nullptr)
return;
if (show_frame_index)
strm->Printf("frame #%u: ", m_frame_index);
ExecutionContext exe_ctx(shared_from_this());
Target *target = exe_ctx.GetTargetPtr();
strm->Printf("0x%0*" PRIx64 " ",
target ? (target->GetArchitecture().GetAddressByteSize() * 2)
: 16,
GetFrameCodeAddress().GetLoadAddress(target));
GetSymbolContext(eSymbolContextEverything);
const bool show_module = true;
const bool show_inline = true;
const bool show_function_arguments = true;
const bool show_function_name = true;
m_sc.DumpStopContext(strm, exe_ctx.GetBestExecutionContextScope(),
GetFrameCodeAddress(), show_fullpaths, show_module,
show_inline, show_function_arguments,
show_function_name);
}
void StackFrame::UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
assert(GetStackID() ==
prev_frame.GetStackID()); // TODO: remove this after some testing
m_variable_list_sp = prev_frame.m_variable_list_sp;
m_variable_list_value_objects.Swap(prev_frame.m_variable_list_value_objects);
if (!m_disassembly.GetString().empty()) {
m_disassembly.Clear();
m_disassembly.PutCString(prev_frame.m_disassembly.GetString());
}
}
void StackFrame::UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
assert(GetStackID() ==
curr_frame.GetStackID()); // TODO: remove this after some testing
m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value
assert(GetThread() == curr_frame.GetThread());
m_frame_index = curr_frame.m_frame_index;
m_concrete_frame_index = curr_frame.m_concrete_frame_index;
m_reg_context_sp = curr_frame.m_reg_context_sp;
m_frame_code_addr = curr_frame.m_frame_code_addr;
m_behaves_like_zeroth_frame = curr_frame.m_behaves_like_zeroth_frame;
assert(!m_sc.target_sp || !curr_frame.m_sc.target_sp ||
m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
assert(!m_sc.module_sp || !curr_frame.m_sc.module_sp ||
m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
assert(m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr ||
m_sc.comp_unit == curr_frame.m_sc.comp_unit);
assert(m_sc.function == nullptr || curr_frame.m_sc.function == nullptr ||
m_sc.function == curr_frame.m_sc.function);
m_sc = curr_frame.m_sc;
m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
m_flags.Set(m_sc.GetResolvedMask());
m_frame_base.Clear();
m_frame_base_error.Clear();
}
bool StackFrame::HasCachedData() const {
if (m_variable_list_sp)
return true;
if (m_variable_list_value_objects.GetSize() > 0)
return true;
if (!m_disassembly.GetString().empty())
return true;
return false;
}
bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
bool show_unique, const char *frame_marker) {
if (show_frame_info) {
strm.Indent();
DumpUsingSettingsFormat(&strm, show_unique, frame_marker);
}
if (show_source) {
ExecutionContext exe_ctx(shared_from_this());
bool have_source = false, have_debuginfo = false;
Debugger::StopDisassemblyType disasm_display =
Debugger::eStopDisassemblyTypeNever;
Target *target = exe_ctx.GetTargetPtr();
if (target) {
Debugger &debugger = target->GetDebugger();
const uint32_t source_lines_before =
debugger.GetStopSourceLineCount(true);
const uint32_t source_lines_after =
debugger.GetStopSourceLineCount(false);
disasm_display = debugger.GetStopDisassemblyDisplay();
GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry);
if (m_sc.comp_unit && m_sc.line_entry.IsValid()) {
have_debuginfo = true;
if (source_lines_before > 0 || source_lines_after > 0) {
size_t num_lines =
target->GetSourceManager().DisplaySourceLinesWithLineNumbers(
m_sc.line_entry.file, m_sc.line_entry.line,
m_sc.line_entry.column, source_lines_before,
source_lines_after, "->", &strm);
if (num_lines != 0)
have_source = true;
// TODO: Give here a one time warning if source file is missing.
}
}
switch (disasm_display) {
case Debugger::eStopDisassemblyTypeNever:
break;
case Debugger::eStopDisassemblyTypeNoDebugInfo:
if (have_debuginfo)
break;
LLVM_FALLTHROUGH;
case Debugger::eStopDisassemblyTypeNoSource:
if (have_source)
break;
LLVM_FALLTHROUGH;
case Debugger::eStopDisassemblyTypeAlways:
if (target) {
const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
if (disasm_lines > 0) {
const ArchSpec &target_arch = target->GetArchitecture();
const char *plugin_name = nullptr;
const char *flavor = nullptr;
const bool mixed_source_and_assembly = false;
Disassembler::Disassemble(
target->GetDebugger(), target_arch, plugin_name, flavor,
exe_ctx, GetFrameCodeAddress(),
{Disassembler::Limit::Instructions, disasm_lines},
mixed_source_and_assembly, 0,
Disassembler::eOptionMarkPCAddress, strm);
}
}
break;
}
}
}
return true;
}
RecognizedStackFrameSP StackFrame::GetRecognizedFrame() {
if (!m_recognized_frame_sp) {
m_recognized_frame_sp =
StackFrameRecognizerManager::RecognizeFrame(CalculateStackFrame());
}
return m_recognized_frame_sp;
}
Reference in New Issue View Git Blame Copy Permalink