da2969b105
This updates the DIL implementation to handle smart pointers (accessing field members and dereferencing) in the same way the current 'frame variable' implementation does. It also adds tests for handling smart pointers, as well as some additional DIL tests.
473 lines
17 KiB
C++
473 lines
17 KiB
C++
//===-- DILEval.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/ValueObject/DILEval.h"
|
|
#include "lldb/Symbol/VariableList.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/ValueObject/DILAST.h"
|
|
#include "lldb/ValueObject/ValueObject.h"
|
|
#include "lldb/ValueObject/ValueObjectRegister.h"
|
|
#include "lldb/ValueObject/ValueObjectVariable.h"
|
|
#include "llvm/Support/FormatAdapters.h"
|
|
#include <memory>
|
|
|
|
namespace lldb_private::dil {
|
|
|
|
static lldb::ValueObjectSP LookupStaticIdentifier(
|
|
VariableList &variable_list, std::shared_ptr<StackFrame> exe_scope,
|
|
llvm::StringRef name_ref, llvm::StringRef unqualified_name) {
|
|
// First look for an exact match to the (possibly) qualified name.
|
|
for (const lldb::VariableSP &var_sp : variable_list) {
|
|
lldb::ValueObjectSP valobj_sp(
|
|
ValueObjectVariable::Create(exe_scope.get(), var_sp));
|
|
if (valobj_sp && valobj_sp->GetVariable() &&
|
|
(valobj_sp->GetVariable()->NameMatches(ConstString(name_ref))))
|
|
return valobj_sp;
|
|
}
|
|
|
|
// If the qualified name is the same as the unqualfied name, there's nothing
|
|
// more to be done.
|
|
if (name_ref == unqualified_name)
|
|
return nullptr;
|
|
|
|
// We didn't match the qualified name; try to match the unqualified name.
|
|
for (const lldb::VariableSP &var_sp : variable_list) {
|
|
lldb::ValueObjectSP valobj_sp(
|
|
ValueObjectVariable::Create(exe_scope.get(), var_sp));
|
|
if (valobj_sp && valobj_sp->GetVariable() &&
|
|
(valobj_sp->GetVariable()->NameMatches(ConstString(unqualified_name))))
|
|
return valobj_sp;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
static lldb::VariableSP DILFindVariable(ConstString name,
|
|
lldb::VariableListSP variable_list) {
|
|
lldb::VariableSP exact_match;
|
|
std::vector<lldb::VariableSP> possible_matches;
|
|
|
|
for (lldb::VariableSP var_sp : *variable_list) {
|
|
llvm::StringRef str_ref_name = var_sp->GetName().GetStringRef();
|
|
// Check for global vars, which might start with '::'.
|
|
str_ref_name.consume_front("::");
|
|
|
|
if (str_ref_name == name.GetStringRef())
|
|
possible_matches.push_back(var_sp);
|
|
else if (var_sp->NameMatches(name))
|
|
possible_matches.push_back(var_sp);
|
|
}
|
|
|
|
// Look for exact matches (favors local vars over global vars)
|
|
auto exact_match_it =
|
|
llvm::find_if(possible_matches, [&](lldb::VariableSP var_sp) {
|
|
return var_sp->GetName() == name;
|
|
});
|
|
|
|
if (exact_match_it != possible_matches.end())
|
|
return *exact_match_it;
|
|
|
|
// Look for a global var exact match.
|
|
for (auto var_sp : possible_matches) {
|
|
llvm::StringRef str_ref_name = var_sp->GetName().GetStringRef();
|
|
str_ref_name.consume_front("::");
|
|
if (str_ref_name == name.GetStringRef())
|
|
return var_sp;
|
|
}
|
|
|
|
// If there's a single non-exact match, take it.
|
|
if (possible_matches.size() == 1)
|
|
return possible_matches[0];
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
lldb::ValueObjectSP LookupGlobalIdentifier(
|
|
llvm::StringRef name_ref, std::shared_ptr<StackFrame> stack_frame,
|
|
lldb::TargetSP target_sp, lldb::DynamicValueType use_dynamic,
|
|
CompilerType *scope_ptr) {
|
|
// First look for match in "local" global variables.
|
|
lldb::VariableListSP variable_list(stack_frame->GetInScopeVariableList(true));
|
|
name_ref.consume_front("::");
|
|
|
|
lldb::ValueObjectSP value_sp;
|
|
if (variable_list) {
|
|
lldb::VariableSP var_sp =
|
|
DILFindVariable(ConstString(name_ref), variable_list);
|
|
if (var_sp)
|
|
value_sp =
|
|
stack_frame->GetValueObjectForFrameVariable(var_sp, use_dynamic);
|
|
}
|
|
|
|
if (value_sp)
|
|
return value_sp;
|
|
|
|
// Also check for static global vars.
|
|
if (variable_list) {
|
|
const char *type_name = "";
|
|
if (scope_ptr)
|
|
type_name = scope_ptr->GetCanonicalType().GetTypeName().AsCString();
|
|
std::string name_with_type_prefix =
|
|
llvm::formatv("{0}::{1}", type_name, name_ref).str();
|
|
value_sp = LookupStaticIdentifier(*variable_list, stack_frame,
|
|
name_with_type_prefix, name_ref);
|
|
if (!value_sp)
|
|
value_sp = LookupStaticIdentifier(*variable_list, stack_frame, name_ref,
|
|
name_ref);
|
|
}
|
|
|
|
if (value_sp)
|
|
return value_sp;
|
|
|
|
// Check for match in modules global variables.
|
|
VariableList modules_var_list;
|
|
target_sp->GetImages().FindGlobalVariables(
|
|
ConstString(name_ref), std::numeric_limits<uint32_t>::max(),
|
|
modules_var_list);
|
|
if (modules_var_list.Empty())
|
|
return nullptr;
|
|
|
|
for (const lldb::VariableSP &var_sp : modules_var_list) {
|
|
std::string qualified_name = llvm::formatv("::{0}", name_ref).str();
|
|
if (var_sp->NameMatches(ConstString(name_ref)) ||
|
|
var_sp->NameMatches(ConstString(qualified_name))) {
|
|
value_sp = ValueObjectVariable::Create(stack_frame.get(), var_sp);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (value_sp)
|
|
return value_sp;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
lldb::ValueObjectSP LookupIdentifier(llvm::StringRef name_ref,
|
|
std::shared_ptr<StackFrame> stack_frame,
|
|
lldb::DynamicValueType use_dynamic,
|
|
CompilerType *scope_ptr) {
|
|
// Support $rax as a special syntax for accessing registers.
|
|
// Will return an invalid value in case the requested register doesn't exist.
|
|
if (name_ref.consume_front("$")) {
|
|
lldb::RegisterContextSP reg_ctx(stack_frame->GetRegisterContext());
|
|
if (!reg_ctx)
|
|
return nullptr;
|
|
|
|
if (const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(name_ref))
|
|
return ValueObjectRegister::Create(stack_frame.get(), reg_ctx, reg_info);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
lldb::VariableListSP variable_list(
|
|
stack_frame->GetInScopeVariableList(false));
|
|
|
|
if (!name_ref.contains("::")) {
|
|
if (!scope_ptr || !scope_ptr->IsValid()) {
|
|
// Lookup in the current frame.
|
|
// Try looking for a local variable in current scope.
|
|
lldb::ValueObjectSP value_sp;
|
|
if (variable_list) {
|
|
lldb::VariableSP var_sp =
|
|
DILFindVariable(ConstString(name_ref), variable_list);
|
|
if (var_sp)
|
|
value_sp =
|
|
stack_frame->GetValueObjectForFrameVariable(var_sp, use_dynamic);
|
|
}
|
|
if (!value_sp)
|
|
value_sp = stack_frame->FindVariable(ConstString(name_ref));
|
|
|
|
if (value_sp)
|
|
return value_sp;
|
|
|
|
// Try looking for an instance variable (class member).
|
|
SymbolContext sc = stack_frame->GetSymbolContext(
|
|
lldb::eSymbolContextFunction | lldb::eSymbolContextBlock);
|
|
llvm::StringRef ivar_name = sc.GetInstanceVariableName();
|
|
value_sp = stack_frame->FindVariable(ConstString(ivar_name));
|
|
if (value_sp)
|
|
value_sp = value_sp->GetChildMemberWithName(name_ref);
|
|
|
|
if (value_sp)
|
|
return value_sp;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
Interpreter::Interpreter(lldb::TargetSP target, llvm::StringRef expr,
|
|
std::shared_ptr<StackFrame> frame_sp,
|
|
lldb::DynamicValueType use_dynamic, bool use_synthetic,
|
|
bool fragile_ivar, bool check_ptr_vs_member)
|
|
: m_target(std::move(target)), m_expr(expr), m_exe_ctx_scope(frame_sp),
|
|
m_use_dynamic(use_dynamic), m_use_synthetic(use_synthetic),
|
|
m_fragile_ivar(fragile_ivar), m_check_ptr_vs_member(check_ptr_vs_member) {
|
|
}
|
|
|
|
llvm::Expected<lldb::ValueObjectSP> Interpreter::Evaluate(const ASTNode *node) {
|
|
// Evaluate an AST.
|
|
auto value_or_error = node->Accept(this);
|
|
// Return the computed value-or-error. The caller is responsible for
|
|
// checking if an error occured during the evaluation.
|
|
return value_or_error;
|
|
}
|
|
|
|
llvm::Expected<lldb::ValueObjectSP>
|
|
Interpreter::Visit(const IdentifierNode *node) {
|
|
lldb::DynamicValueType use_dynamic = m_use_dynamic;
|
|
|
|
lldb::ValueObjectSP identifier =
|
|
LookupIdentifier(node->GetName(), m_exe_ctx_scope, use_dynamic);
|
|
|
|
if (!identifier)
|
|
identifier = LookupGlobalIdentifier(node->GetName(), m_exe_ctx_scope,
|
|
m_target, use_dynamic);
|
|
if (!identifier) {
|
|
std::string errMsg =
|
|
llvm::formatv("use of undeclared identifier '{0}'", node->GetName());
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, errMsg, node->GetLocation(), node->GetName().size());
|
|
}
|
|
|
|
return identifier;
|
|
}
|
|
|
|
llvm::Expected<lldb::ValueObjectSP>
|
|
Interpreter::Visit(const UnaryOpNode *node) {
|
|
Status error;
|
|
auto rhs_or_err = Evaluate(node->GetOperand());
|
|
if (!rhs_or_err)
|
|
return rhs_or_err;
|
|
|
|
lldb::ValueObjectSP rhs = *rhs_or_err;
|
|
|
|
switch (node->GetKind()) {
|
|
case UnaryOpKind::Deref: {
|
|
lldb::ValueObjectSP dynamic_rhs = rhs->GetDynamicValue(m_use_dynamic);
|
|
if (dynamic_rhs)
|
|
rhs = dynamic_rhs;
|
|
|
|
lldb::ValueObjectSP child_sp = rhs->Dereference(error);
|
|
if (!child_sp && m_use_synthetic) {
|
|
if (lldb::ValueObjectSP synth_obj_sp = rhs->GetSyntheticValue()) {
|
|
error.Clear();
|
|
child_sp = synth_obj_sp->Dereference(error);
|
|
}
|
|
}
|
|
if (error.Fail())
|
|
return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(),
|
|
node->GetLocation());
|
|
|
|
return child_sp;
|
|
}
|
|
case UnaryOpKind::AddrOf: {
|
|
Status error;
|
|
lldb::ValueObjectSP value = rhs->AddressOf(error);
|
|
if (error.Fail())
|
|
return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(),
|
|
node->GetLocation());
|
|
|
|
return value;
|
|
}
|
|
}
|
|
|
|
// Unsupported/invalid operation.
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, "invalid ast: unexpected binary operator", node->GetLocation());
|
|
}
|
|
|
|
llvm::Expected<lldb::ValueObjectSP>
|
|
Interpreter::Visit(const MemberOfNode *node) {
|
|
auto base_or_err = Evaluate(node->GetBase());
|
|
if (!base_or_err)
|
|
return base_or_err;
|
|
bool expr_is_ptr = node->GetIsArrow();
|
|
lldb::ValueObjectSP base = *base_or_err;
|
|
|
|
// Perform some basic type & correctness checking.
|
|
if (node->GetIsArrow()) {
|
|
if (!m_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 =
|
|
base->GetCompilerType().GetTypeInfo(nullptr);
|
|
if ((pointer_type_flags & lldb::eTypeIsObjC) &&
|
|
(pointer_type_flags & lldb::eTypeIsPointer)) {
|
|
// This was an objective C object pointer and it was requested we
|
|
// skip any fragile ivars so return nothing here
|
|
return lldb::ValueObjectSP();
|
|
}
|
|
}
|
|
|
|
// If we have a non-pointer type with a synthetic value then lets check
|
|
// if we have a synthetic dereference specified.
|
|
if (!base->IsPointerType() && base->HasSyntheticValue()) {
|
|
Status deref_error;
|
|
if (lldb::ValueObjectSP synth_deref_sp =
|
|
base->GetSyntheticValue()->Dereference(deref_error);
|
|
synth_deref_sp && deref_error.Success()) {
|
|
base = std::move(synth_deref_sp);
|
|
}
|
|
if (!base || deref_error.Fail()) {
|
|
std::string errMsg = llvm::formatv(
|
|
"Failed to dereference synthetic value: {0}", deref_error);
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
|
|
}
|
|
|
|
// Some synthetic plug-ins fail to set the error in Dereference
|
|
if (!base) {
|
|
std::string errMsg = "Failed to dereference synthetic value";
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
|
|
}
|
|
expr_is_ptr = false;
|
|
}
|
|
}
|
|
|
|
if (m_check_ptr_vs_member) {
|
|
bool base_is_ptr = base->IsPointerType();
|
|
|
|
if (expr_is_ptr != base_is_ptr) {
|
|
if (base_is_ptr) {
|
|
std::string errMsg =
|
|
llvm::formatv("member reference type {0} is a pointer; "
|
|
"did you mean to use '->'?",
|
|
base->GetCompilerType().TypeDescription());
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
|
|
} else {
|
|
std::string errMsg =
|
|
llvm::formatv("member reference type {0} is not a pointer; "
|
|
"did you mean to use '.'?",
|
|
base->GetCompilerType().TypeDescription());
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
|
|
}
|
|
}
|
|
}
|
|
|
|
lldb::ValueObjectSP field_obj =
|
|
base->GetChildMemberWithName(node->GetFieldName());
|
|
if (!field_obj) {
|
|
if (m_use_synthetic) {
|
|
field_obj = base->GetSyntheticValue();
|
|
if (field_obj)
|
|
field_obj = field_obj->GetChildMemberWithName(node->GetFieldName());
|
|
}
|
|
|
|
if (!m_use_synthetic || !field_obj) {
|
|
std::string errMsg = llvm::formatv(
|
|
"no member named '{0}' in {1}", node->GetFieldName(),
|
|
base->GetCompilerType().GetFullyUnqualifiedType().TypeDescription());
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
|
|
}
|
|
}
|
|
|
|
if (field_obj && field_obj->GetName() == node->GetFieldName()) {
|
|
if (m_use_dynamic != lldb::eNoDynamicValues) {
|
|
lldb::ValueObjectSP dynamic_val_sp =
|
|
field_obj->GetDynamicValue(m_use_dynamic);
|
|
if (dynamic_val_sp)
|
|
field_obj = dynamic_val_sp;
|
|
}
|
|
return field_obj;
|
|
}
|
|
|
|
CompilerType base_type = base->GetCompilerType();
|
|
if (node->GetIsArrow() && base->IsPointerType())
|
|
base_type = base_type.GetPointeeType();
|
|
std::string errMsg =
|
|
llvm::formatv("no member named '{0}' in {1}", node->GetFieldName(),
|
|
base_type.GetFullyUnqualifiedType().TypeDescription());
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
|
|
}
|
|
|
|
llvm::Expected<lldb::ValueObjectSP>
|
|
Interpreter::Visit(const ArraySubscriptNode *node) {
|
|
auto lhs_or_err = Evaluate(node->GetBase());
|
|
if (!lhs_or_err)
|
|
return lhs_or_err;
|
|
lldb::ValueObjectSP base = *lhs_or_err;
|
|
|
|
// Check to see if 'base' has a synthetic value; if so, try using that.
|
|
uint64_t child_idx = node->GetIndex();
|
|
if (lldb::ValueObjectSP synthetic = base->GetSyntheticValue()) {
|
|
llvm::Expected<uint32_t> num_children =
|
|
synthetic->GetNumChildren(child_idx + 1);
|
|
if (!num_children)
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, toString(num_children.takeError()), node->GetLocation());
|
|
if (child_idx >= *num_children) {
|
|
std::string message = llvm::formatv(
|
|
"array index {0} is not valid for \"({1}) {2}\"", child_idx,
|
|
base->GetTypeName().AsCString("<invalid type>"),
|
|
base->GetName().AsCString());
|
|
return llvm::make_error<DILDiagnosticError>(m_expr, message,
|
|
node->GetLocation());
|
|
}
|
|
if (lldb::ValueObjectSP child_valobj_sp =
|
|
synthetic->GetChildAtIndex(child_idx))
|
|
return child_valobj_sp;
|
|
}
|
|
|
|
auto base_type = base->GetCompilerType().GetNonReferenceType();
|
|
if (!base_type.IsPointerType() && !base_type.IsArrayType())
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, "subscripted value is not an array or pointer",
|
|
node->GetLocation());
|
|
if (base_type.IsPointerToVoid())
|
|
return llvm::make_error<DILDiagnosticError>(
|
|
m_expr, "subscript of pointer to incomplete type 'void'",
|
|
node->GetLocation());
|
|
|
|
if (base_type.IsArrayType()) {
|
|
if (lldb::ValueObjectSP child_valobj_sp = base->GetChildAtIndex(child_idx))
|
|
return child_valobj_sp;
|
|
}
|
|
|
|
int64_t signed_child_idx = node->GetIndex();
|
|
return base->GetSyntheticArrayMember(signed_child_idx, true);
|
|
}
|
|
|
|
llvm::Expected<lldb::ValueObjectSP>
|
|
Interpreter::Visit(const BitFieldExtractionNode *node) {
|
|
auto lhs_or_err = Evaluate(node->GetBase());
|
|
if (!lhs_or_err)
|
|
return lhs_or_err;
|
|
lldb::ValueObjectSP base = *lhs_or_err;
|
|
int64_t first_index = node->GetFirstIndex();
|
|
int64_t last_index = node->GetLastIndex();
|
|
|
|
// if the format given is [high-low], swap range
|
|
if (first_index > last_index)
|
|
std::swap(first_index, last_index);
|
|
|
|
Status error;
|
|
if (base->GetCompilerType().IsReferenceType()) {
|
|
base = base->Dereference(error);
|
|
if (error.Fail())
|
|
return error.ToError();
|
|
}
|
|
lldb::ValueObjectSP child_valobj_sp =
|
|
base->GetSyntheticBitFieldChild(first_index, last_index, true);
|
|
if (!child_valobj_sp) {
|
|
std::string message = llvm::formatv(
|
|
"bitfield range {0}-{1} is not valid for \"({2}) {3}\"", first_index,
|
|
last_index, base->GetTypeName().AsCString("<invalid type>"),
|
|
base->GetName().AsCString());
|
|
return llvm::make_error<DILDiagnosticError>(m_expr, message,
|
|
node->GetLocation());
|
|
}
|
|
return child_valobj_sp;
|
|
}
|
|
|
|
} // namespace lldb_private::dil
|