================ @@ -0,0 +1,106 @@ +//===-- DILEval.h -----------------------------------------------*- C++ -*-===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_VALUEOBJECT_DILEVAL_H_ +#define LLDB_VALUEOBJECT_DILEVAL_H_ + +#include "lldb/ValueObject/DILAST.h" +#include "lldb/ValueObject/DILParser.h" +#include <memory> +#include <vector> + +namespace lldb_private { + +namespace dil { + +/// Class used to store & manipulate information about identifiers. +class IdentifierInfo { +public: + enum class Kind { + eValue, + eContextArg, + }; + + static std::unique_ptr<IdentifierInfo> FromValue(ValueObject &valobj) { + CompilerType type; + type = valobj.GetCompilerType(); + return std::unique_ptr<IdentifierInfo>( + new IdentifierInfo(Kind::eValue, type, valobj.GetSP(), {})); + } + + static std::unique_ptr<IdentifierInfo> FromContextArg(CompilerType type) { + lldb::ValueObjectSP empty_value; + return std::unique_ptr<IdentifierInfo>( + new IdentifierInfo(Kind::eContextArg, type, empty_value, {})); + } + + Kind GetKind() const { return m_kind; } + lldb::ValueObjectSP GetValue() const { return m_value; } + + CompilerType GetType() { return m_type; } + bool IsValid() const { return m_type.IsValid(); } + + IdentifierInfo(Kind kind, CompilerType type, lldb::ValueObjectSP value, + std::vector<uint32_t> path) + : m_kind(kind), m_type(type), m_value(std::move(value)) {} + +private: + Kind m_kind; + CompilerType m_type; + lldb::ValueObjectSP m_value; +}; + +/// Given the name of an identifier (variable name, member name, type name, +/// etc.), find the ValueObject for that name (if it exists) and create and +/// return an IdentifierInfo object containing all the relevant information +/// about that object (for DIL parsing and evaluating). +std::unique_ptr<IdentifierInfo> LookupIdentifier( + const std::string &name, std::shared_ptr<ExecutionContextScope> ctx_scope, + lldb::DynamicValueType use_dynamic, CompilerType *scope_ptr = nullptr); + +class DILInterpreter : Visitor { +public: + DILInterpreter(lldb::TargetSP target, llvm::StringRef expr, + lldb::DynamicValueType use_dynamic, + std::shared_ptr<ExecutionContextScope> exe_ctx_scope); + + llvm::Expected<lldb::ValueObjectSP> DILEval(const DILASTNode *tree, + lldb::TargetSP target_sp); + +private: + lldb::ValueObjectSP DILEvalNode(const DILASTNode *node); + + bool Success() { return m_error.Success(); } + + void SetError(ErrorCode error_code, std::string error, uint32_t loc); + + void Visit(const ErrorNode *node) override; + void Visit(const IdentifierNode *node) override; + +private: + // Used by the interpreter to create objects, perform casts, etc. + lldb::TargetSP m_target; + + llvm::StringRef m_expr; + + lldb::ValueObjectSP m_result; + + lldb::ValueObjectSP m_scope; + + lldb::DynamicValueType m_default_dynamic; + + Status m_error; ---------------- adrian-prantl wrote:
Is there a good reason why you need a long-lived Status object here? We should try to replace every Status member with methods that return llvm::Error or llvm::Expected. Otherwise it's very easy for an error to get overwritten without being checked/consumed. https://github.com/llvm/llvm-project/pull/120971 _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
