================ @@ -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> ---------------- labath wrote:
Why do we actually want this function to work on something like `C[2]`? That's definitely not what I would have expected from the function signature (nor from its implementation, actually). Even that was the behavior we want (which I really hope isn't the case), the other implementation might still make more sense, because it would give you a chance to explain what you're doing and why. Right now, this function looks like it's trying to reimplement `TypeSystemClang::GetIndexOfChildMemberWithName` without any indication of why. I wouldn't be surprised if it didn't work with other languages due to its reliance on how TypeSystemClang or C++ represent certain constructs. (This extraction of information from the types could be part of why you're needing to detect if something is a smart pointer, etc. We currently don't have a way to tell if a type represents a smart pointer -- we can only do that for a specific value of a that type) 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
