================
@@ -0,0 +1,560 @@
+//===-- DILAST.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/Core/DILAST.h"
+#include "lldb/API/SBType.h"
+#include "lldb/Core/ValueObjectRegister.h"
+#include "lldb/Core/ValueObjectVariable.h"
+#include "lldb/Symbol/TypeList.h"
+#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/LanguageRuntime.h"
+#include "lldb/Target/RegisterContext.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <vector>
+
+namespace lldb_private {
+
+namespace DIL {
+
+lldb::ValueObjectSP
+GetDynamicOrSyntheticValue(lldb::ValueObjectSP in_valobj_sp,
+ lldb::DynamicValueType use_dynamic,
+ bool use_synthetic) {
+ Status error;
+
+ if (!in_valobj_sp) {
+ error.SetErrorString("invalid value object");
+ return in_valobj_sp;
+ }
+
+ lldb::ValueObjectSP value_sp = in_valobj_sp;
+
+ Target *target = value_sp->GetTargetSP().get();
+ // If this ValueObject holds an error, then it is valuable for that.
+ if (value_sp->GetError().Fail())
+ return value_sp;
+
+ if (!target)
+ return lldb::ValueObjectSP();
+
+ if (use_dynamic != lldb::eNoDynamicValues) {
+ lldb::ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(use_dynamic);
+ if (dynamic_sp)
+ value_sp = dynamic_sp;
+ }
+
+ if (use_synthetic) {
+ lldb::ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue();
+ if (synthetic_sp)
+ value_sp = synthetic_sp;
+ }
+
+ if (!value_sp)
+ error.SetErrorString("invalid value object");
+
+ return value_sp;
+}
+
+CompilerType DILASTNode::GetDereferencedResultType() const {
+ auto type = result_type();
+ return type.IsReferenceType() ? type.GetNonReferenceType() : type;
+}
+
+std::optional<MemberInfo>
+GetFieldWithNameIndexPath(lldb::ValueObjectSP lhs_val_sp, CompilerType type,
+ const std::string &name, std::vector<uint32_t> *idx,
+ CompilerType empty_type, bool use_synthetic,
+ bool is_dynamic) {
+ bool is_synthetic = false;
+ // Go through the fields first.
+ uint32_t num_fields = type.GetNumFields();
+ lldb::ValueObjectSP empty_valobj_sp;
+ for (uint32_t i = 0; i < num_fields; ++i) {
+ uint64_t bit_offset = 0;
+ uint32_t bitfield_bit_size = 0;
+ bool is_bitfield = false;
+ std::string name_sstr;
+ CompilerType field_type(type.GetFieldAtIndex(
+ i, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield));
+ auto field_name =
+ name_sstr.length() == 0 ? std::optional<std::string>() : name_sstr;
+ if (field_type.IsValid()) {
+ std::optional<uint32_t> size_in_bits;
+ if (is_bitfield)
+ size_in_bits = bitfield_bit_size;
+ struct MemberInfo field = {field_name, field_type, size_in_bits,
+ is_synthetic, is_dynamic, empty_valobj_sp};
+
+ // Name can be null if this is a padding field.
+ if (field.name == name) {
+ if (lhs_val_sp) {
+ lldb::ValueObjectSP child_valobj_sp =
+ lhs_val_sp->GetChildMemberWithName(name);
+ if (child_valobj_sp)
+ field.val_obj_sp = child_valobj_sp;
+ }
+
+ if (idx) {
+ assert(idx->empty());
+ // Direct base classes are located before fields, so field members
+ // needs to be offset by the number of base classes.
+ idx->push_back(i + type.GetNumberOfNonEmptyBaseClasses());
+ }
+ return field;
+ } else if (field.type.IsAnonymousType()) {
+ // Every member of an anonymous struct is considered to be a member of
+ // the enclosing struct or union. This applies recursively if the
+ // enclosing struct or union is also anonymous.
+
+ assert(!field.name && "Field should be unnamed.");
+
+ std::optional<MemberInfo> field_in_anon_type =
+ GetFieldWithNameIndexPath(lhs_val_sp, field.type, name, idx,
+ empty_type, use_synthetic, is_dynamic);
+ if (field_in_anon_type) {
+ if (idx) {
+ idx->push_back(i + type.GetNumberOfNonEmptyBaseClasses());
+ }
+ return field_in_anon_type.value();
+ }
+ }
+ }
+ }
+
+ // LLDB can't access inherited fields of anonymous struct members.
+ if (type.IsAnonymousType()) {
+ return {};
+ }
+
+ // Go through the base classes and look for the field there.
+ uint32_t num_non_empty_bases = 0;
+ uint32_t num_direct_bases = type.GetNumDirectBaseClasses();
+ for (uint32_t i = 0; i < num_direct_bases; ++i) {
+ uint32_t bit_offset;
+ auto base = type.GetDirectBaseClassAtIndex(i, &bit_offset);
+ auto field = GetFieldWithNameIndexPath(
+ lhs_val_sp, base, name, idx, empty_type, use_synthetic, is_dynamic);
+ if (field) {
+ if (idx) {
+ idx->push_back(num_non_empty_bases);
+ }
+ return field.value();
+ }
+ if (base.GetNumFields() > 0) {
+ num_non_empty_bases += 1;
+ }
+ }
+
+ // Check for synthetic member
+ if (lhs_val_sp && use_synthetic) {
+ lldb::ValueObjectSP child_valobj_sp = lhs_val_sp->GetSyntheticValue();
+ if (child_valobj_sp) {
+ is_synthetic = true;
+ uint32_t child_idx = child_valobj_sp->GetIndexOfChildWithName(name);
+ child_valobj_sp = child_valobj_sp->GetChildMemberWithName(name);
+ if (child_valobj_sp) {
+ CompilerType field_type = child_valobj_sp->GetCompilerType();
+ if (field_type.IsValid()) {
+ struct MemberInfo field = {name, field_type, {},
+ is_synthetic, is_dynamic,
child_valobj_sp};
+ if (idx) {
+ assert(idx->empty());
+ idx->push_back(child_idx);
+ }
+ return field;
+ }
+ }
+ }
+ }
+
+ if (lhs_val_sp) {
+ lldb::ValueObjectSP dynamic_val_sp =
+ lhs_val_sp->GetDynamicValue(lldb::eDynamicDontRunTarget);
+ if (dynamic_val_sp) {
+ CompilerType lhs_type = dynamic_val_sp->GetCompilerType();
+ if (lhs_type.IsPointerType())
+ lhs_type = lhs_type.GetPointeeType();
+ is_dynamic = true;
+ return GetFieldWithNameIndexPath(dynamic_val_sp, lhs_type, name, idx,
+ empty_type, use_synthetic, is_dynamic);
+ }
+ }
+
+ return {};
+}
+
+std::tuple<std::optional<MemberInfo>, std::vector<uint32_t>>
+GetMemberInfo(lldb::ValueObjectSP lhs_val_sp, CompilerType type,
+ const std::string &name, bool use_synthetic) {
+ std::vector<uint32_t> idx;
+ CompilerType empty_type;
+ bool is_dynamic = false;
+ std::optional<MemberInfo> member = GetFieldWithNameIndexPath(
+ lhs_val_sp, type, name, &idx, empty_type, use_synthetic, is_dynamic);
+ std::reverse(idx.begin(), idx.end());
+ return {member, std::move(idx)};
+}
+
+static lldb::ValueObjectSP
+LookupStaticIdentifier(lldb::TargetSP target_sp,
+ const llvm::StringRef &name_ref,
+ ConstString unqualified_name) {
+ // List global variable with the same "basename". There can be many matches
+ // from other scopes (namespaces, classes), so we do additional filtering
+ // later.
+ std::vector<lldb::ValueObjectSP> values;
+ VariableList variable_list;
+ ConstString name(name_ref);
+ target_sp->GetImages().FindGlobalVariables(
+ name, (size_t)std::numeric_limits<uint32_t>::max, variable_list);
+ if (!variable_list.Empty()) {
+ ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
+ if (exe_scope == nullptr)
+ exe_scope = target_sp.get();
+ for (const lldb::VariableSP &var_sp : variable_list) {
+ lldb::ValueObjectSP valobj_sp(
+ ValueObjectVariable::Create(exe_scope, var_sp));
+ if (valobj_sp)
+ values.push_back(valobj_sp);
+ }
+ }
+
+ // Find the corrent variable by matching the name.
+ for (uint32_t i = 0; i < values.size(); ++i) {
+ lldb::ValueObjectSP val = values[i];
+ if (val->GetVariable() &&
+ (val->GetVariable()->NameMatches(unqualified_name) ||
+ val->GetVariable()->NameMatches(ConstString(name_ref))))
+ return val;
+ }
+ lldb::ValueObjectSP empty_obj_sp;
+ return empty_obj_sp;
----------------
labath wrote:
`return nullptr` or `return {}` works just fine.
https://github.com/llvm/llvm-project/pull/95738
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
