shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/lldb/source/ValueObject/DILEval.cpp
cmtice 6d3ad9d9fd
[LLDB] Update DIL handling of array subscripting. (#151605) 
This updates the DIL code for handling array subscripting to more
closely match and handle all the cases from the original 'frame var'
implementation. Also updates the DIL array subscripting test. This
particularly fixes some issues with handling synthetic children, objc
pointers, and accessing specific bits within scalar data types.
2025-08-15 08:26:45 -07:00

449 lines
16 KiB
C++
Raw Blame History

//===-- 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/CompileUnit.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::VariableSP DILFindVariable(ConstString name,
VariableList &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();
str_ref_name.consume_front("::");
// Check for the exact same match
if (str_ref_name == name.GetStringRef())
return var_sp;
// Check for possible matches by base name
if (var_sp->NameMatches(name))
possible_matches.push_back(var_sp);
}
// If there's a non-exact match, take it.
if (possible_matches.size() > 0)
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) {
// Get a global variables list without the locals from the current frame
SymbolContext symbol_context =
stack_frame->GetSymbolContext(lldb::eSymbolContextCompUnit);
lldb::VariableListSP variable_list;
if (symbol_context.comp_unit)
variable_list = symbol_context.comp_unit->GetVariableList(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;
// 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()) {
lldb::VariableSP var_sp =
DILFindVariable(ConstString(name_ref), modules_var_list);
if (var_sp)
value_sp = ValueObjectVariable::Create(stack_frame.get(), var_sp);
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) {
// 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;
}
if (!name_ref.contains("::")) {
// Lookup in the current frame.
// Try looking for a local variable in current scope.
lldb::VariableListSP variable_list(
stack_frame->GetInScopeVariableList(false));
lldb::ValueObjectSP value_sp;
if (variable_list) {
lldb::VariableSP var_sp =
variable_list->FindVariable(ConstString(name_ref));
if (var_sp)
value_sp =
stack_frame->GetValueObjectForFrameVariable(var_sp, use_dynamic);
}
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(
"\"{0}\" is not a member of \"({1}) {2}\"", node->GetFieldName(),
base->GetTypeName().AsCString("<invalid type>"), base->GetName());
return llvm::make_error<DILDiagnosticError>(
m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
}
}
if (field_obj) {
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(
"\"{0}\" is not a member of \"({1}) {2}\"", node->GetFieldName(),
base->GetTypeName().AsCString("<invalid type>"), base->GetName());
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;
StreamString var_expr_path_strm;
uint64_t child_idx = node->GetIndex();
lldb::ValueObjectSP child_valobj_sp;
bool is_incomplete_array = false;
CompilerType base_type = base->GetCompilerType().GetNonReferenceType();
base->GetExpressionPath(var_expr_path_strm);
if (base_type.IsPointerType()) {
child_valobj_sp = base->GetSyntheticArrayMember(child_idx, true);
if (!child_valobj_sp) {
std::string err_msg = llvm::formatv(
"failed to use pointer as array for index {0} for "
"\"({1}) {2}\"",
child_idx, base->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
if (base_type.IsPointerToVoid())
err_msg = "subscript of pointer to incomplete type 'void'";
return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg),
node->GetLocation());
}
} else if (base_type.IsArrayType(nullptr, nullptr, &is_incomplete_array)) {
child_valobj_sp = base->GetChildAtIndex(child_idx);
if (!child_valobj_sp && (is_incomplete_array || m_use_synthetic))
child_valobj_sp = base->GetSyntheticArrayMember(child_idx, true);
if (!child_valobj_sp) {
std::string err_msg = llvm::formatv(
"array index {0} is not valid for \"({1}) {2}\"", child_idx,
base->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg),
node->GetLocation());
}
} else if (base_type.IsScalarType()) {
child_valobj_sp =
base->GetSyntheticBitFieldChild(child_idx, child_idx, true);
if (!child_valobj_sp) {
std::string err_msg = llvm::formatv(
"bitfield range {0}-{1} is not valid for \"({2}) {3}\"", child_idx,
child_idx, base->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg),
node->GetLocation(), 1);
}
} else {
lldb::ValueObjectSP synthetic = base->GetSyntheticValue();
if (!m_use_synthetic || !synthetic || synthetic == base) {
std::string err_msg =
llvm::formatv("\"{0}\" is not an array type",
base->GetTypeName().AsCString("<invalid type>"));
return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg),
node->GetLocation(), 1);
}
if (static_cast<uint32_t>(child_idx) >=
synthetic->GetNumChildrenIgnoringErrors(child_idx + 1)) {
std::string err_msg = llvm::formatv(
"array index {0} is not valid for \"({1}) {2}\"", child_idx,
base->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg),
node->GetLocation(), 1);
}
child_valobj_sp = synthetic->GetChildAtIndex(child_idx);
if (!child_valobj_sp) {
std::string err_msg = llvm::formatv(
"array index {0} is not valid for \"({1}) {2}\"", child_idx,
base->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetData());
return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg),
node->GetLocation(), 1);
}
}
if (child_valobj_sp) {
if (m_use_dynamic != lldb::eNoDynamicValues) {
if (auto dynamic_sp = child_valobj_sp->GetDynamicValue(m_use_dynamic))
child_valobj_sp = std::move(dynamic_sp);
}
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
Reference in New Issue View Git Blame Copy Permalink