================ @@ -0,0 +1,446 @@ +//===-- DILAST.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_DIL_AST_H_ +#define LLDB_DIL_AST_H_ + +#include <memory> +#include <optional> +#include <string> +#include <variant> +#include <vector> + +#include "lldb/Core/ValueObject.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/TypeList.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/Utility/ConstString.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/TokenKinds.h" +#include "llvm/ADT/APFloat.h" +#include "llvm/ADT/APInt.h" + +namespace lldb_private { + +/// Struct to hold information about member fields. Used by the parser for the +/// Data Inspection Language (DIL). +struct DILMemberInfo { + std::optional<std::string> name; + CompilerType type; + bool is_bitfield; + uint32_t bitfield_size_in_bits; + bool is_synthetic; + bool is_dynamic; + lldb::ValueObjectSP val_obj_sp; + + explicit operator bool() const { return type.IsValid(); } +}; + +/// This determines if the type is a shared, unique or weak pointer, either +/// from stdlibc++ or libc+++. +bool IsSmartPtrType(CompilerType type); + +/// Finds the member field with the given name and type, stores the child index +/// corresponding to the field in the idx vector and returns a DILMemberInfo +/// struct with appropriate information about the field. +DILMemberInfo 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); + +std::tuple<DILMemberInfo, std::vector<uint32_t>> +GetMemberInfo(lldb::ValueObjectSP lhs_val_sp, CompilerType type, + const std::string &name, bool use_synthetic); + +/// Get the appropriate ValueObjectSP, consulting the use_dynamic and +/// use_synthetic options passed, acquiring the process & target locks if +/// appropriate. +lldb::ValueObjectSP +DILGetSPWithLock(lldb::ValueObjectSP valobj_sp, + lldb::DynamicValueType use_dynamic = lldb::eNoDynamicValues, + bool use_synthetic = false); + +/// The various types DIL AST nodes (used by the DIL parser). +enum class DILNodeKind { + kDILErrorNode, + kLiteralNode, + kIdentifierNode, + kBuiltinFunctionCallNode, + kCStyleCastNode, + kMemberOfNode, + kArraySubscriptNode, + kUnaryOpNode, + kSmartPtrToPtrDecay +}; + +/// The C-Style casts allowed by DIL. +enum class CStyleCastKind { + kArithmetic, + kEnumeration, + kPointer, + kNullptr, + kReference, +}; + +/// The Unary operators recognized by DIL. +enum class UnaryOpKind { + AddrOf, // "&" + Deref, // "*" + Minus, // "-" +}; + +/// Given a string representing a type, returns the CompilerType corresponding +/// to the named type, if it exists. +CompilerType +ResolveTypeByName(const std::string &name, + std::shared_ptr<ExecutionContextScope> ctx_scope); + +/// Quick lookup to check if a type name already exists in a +/// name-to-CompilerType map the DIL parser keeps of previously found +/// name/type pairs. +bool IsContextVar(const std::string &name); + +/// Checks to see if the CompilerType is a Smart Pointer (shared, unique, weak) +/// or not. Only applicable for C++, which is why this is here and not part of +/// the CompilerType class. ---------------- cmtice wrote:
I don't understand what you're suggesting here. How would using the synthetic dereference operation help to determine if a pointer variable is a 'smart' pointer vs a regular one? (I'll remove the second declaration; as mentioned above, this function is implemented in the parser file). 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
