DWARFASTParserClang.h

Go to the documentation of this file.

//===-- DWARFASTParserClang.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_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H
#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H
 
#include "clang/AST/CharUnits.h"
#include "clang/AST/Type.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
 
#include "DWARFASTParser.h"
#include "DWARFDIE.h"
#include "DWARFDefines.h"
#include "DWARFFormValue.h"
#include "LogChannelDWARF.h"
#include "lldb/Core/PluginInterface.h"
 
#include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 
#include <optional>
#include <vector>
 
namespace lldb_private {
class CompileUnit;
}
namespace lldb_private::plugin {
namespace dwarf {
class DWARFDebugInfoEntry;
class SymbolFileDWARF;
} // namespace dwarf
} // namespace lldb_private::plugin
 
struct ParsedDWARFTypeAttributes;
 
class DWARFASTParserClang : public lldb_private::plugin::dwarf::DWARFASTParser {
public:
  DWARFASTParserClang(lldb_private::TypeSystemClang &ast);
 
  ~DWARFASTParserClang() override;
 
  // LLVM RTTI support
  static bool classof(const DWARFASTParser *Parser) {
    return Parser->GetKind() == Kind::DWARFASTParserClang;
  }
 
  // DWARFASTParser interface.
  lldb::TypeSP
  ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                     const lldb_private::plugin::dwarf::DWARFDIE &die,
                     bool *type_is_new_ptr) override;
 
  lldb_private::ConstString ConstructDemangledNameFromDWARF(
      const lldb_private::plugin::dwarf::DWARFDIE &die) override;
 
  lldb_private::Function *
  ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                         const lldb_private::plugin::dwarf::DWARFDIE &die,
                         lldb_private::AddressRanges func_ranges) override;
 
  bool CompleteTypeFromDWARF(
      const lldb_private::plugin::dwarf::DWARFDIE &die,
      lldb_private::Type *type,
      const lldb_private::CompilerType &compiler_type) override;
 
  lldb_private::CompilerDecl GetDeclForUIDFromDWARF(
      const lldb_private::plugin::dwarf::DWARFDIE &die) override;
 
  void EnsureAllDIEsInDeclContextHaveBeenParsed(
      lldb_private::CompilerDeclContext decl_context) override;
 
  lldb_private::CompilerDeclContext GetDeclContextForUIDFromDWARF(
      const lldb_private::plugin::dwarf::DWARFDIE &die) override;
 
  lldb_private::CompilerDeclContext GetDeclContextContainingUIDFromDWARF(
      const lldb_private::plugin::dwarf::DWARFDIE &die) override;
 
  lldb_private::ClangASTImporter &GetClangASTImporter();
 
  /// Extracts an value for a given Clang integer type from a DWARFFormValue.
  ///
  /// \param int_type The Clang type that defines the bit size and signedness
  ///                 of the integer that should be extracted. Has to be either
  ///                 an integer type or an enum type. For enum types the
  ///                 underlying integer type will be considered as the
  ///                 expected integer type that should be extracted.
  /// \param form_value The DWARFFormValue that contains the integer value.
  /// \return An APInt containing the same integer value as the given
  ///         DWARFFormValue with the bit width of the given integer type.
  ///         Returns an error if the value in the DWARFFormValue does not fit
  ///         into the given integer type or the integer type isn't supported.
  llvm::Expected<llvm::APInt> ExtractIntFromFormValue(
      const lldb_private::CompilerType &int_type,
      const lldb_private::plugin::dwarf::DWARFFormValue &form_value) const;
 
  /// Returns the template parameters of a class DWARFDIE as a string.
  ///
  /// This is mostly useful for -gsimple-template-names which omits template
  /// parameters from the DIE name and instead always adds template parameter
  /// children DIEs.
  ///
  /// \param die The struct/class DWARFDIE containing template parameters.
  /// \return A string, including surrounding '<>', of the template parameters.
  /// If the DIE's name already has '<>', returns an empty string because
  /// it's assumed that the caller is using the DIE name anyway.
  std::string
  GetDIEClassTemplateParams(lldb_private::plugin::dwarf::DWARFDIE die) override;
 
  void MapDeclDIEToDefDIE(const lldb_private::plugin::dwarf::DWARFDIE &decl_die,
                          const lldb_private::plugin::dwarf::DWARFDIE &def_die);
 
  /// Get the object parameter DIE if one exists, otherwise returns
  /// a default DWARFDIE.
  ///
  /// \param[in] subprogram DIE of function for which to get the object
  /// parameter. \param[in] containing_decl_ctx DIE representing declaration
  /// context of \a subprogram. If this DIE isn't a valid declaration context
  /// for class methods, assume no object parameter exists.
  ///
  /// \returns DIE of object parameter if one exists.
  ///
  lldb_private::plugin::dwarf::DWARFDIE
  GetObjectParameter(const lldb_private::plugin::dwarf::DWARFDIE &subprogram,
                     const lldb_private::plugin::dwarf::DWARFDIE &decl_ctx_die);
 
protected:
  /// Protected typedefs and members.
  /// @{
  class DelayedAddObjCClassProperty;
  typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
 
  typedef llvm::DenseMap<
      const lldb_private::plugin::dwarf::DWARFDebugInfoEntry *,
      clang::DeclContext *>
      DIEToDeclContextMap;
  typedef std::multimap<const clang::DeclContext *,
                        const lldb_private::plugin::dwarf::DWARFDIE>
      DeclContextToDIEMap;
  typedef llvm::DenseMap<
      const lldb_private::plugin::dwarf::DWARFDebugInfoEntry *,
      lldb_private::OptionalClangModuleID>
      DIEToModuleMap;
  typedef llvm::DenseMap<
      const lldb_private::plugin::dwarf::DWARFDebugInfoEntry *, clang::Decl *>
      DIEToDeclMap;
 
  lldb_private::TypeSystemClang &m_ast;
  DIEToDeclMap m_die_to_decl;
  DIEToDeclContextMap m_die_to_decl_ctx;
  DeclContextToDIEMap m_decl_ctx_to_die;
  DIEToModuleMap m_die_to_module;
  std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
  /// @}
 
  clang::DeclContext *
  GetDeclContextForBlock(const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  clang::BlockDecl *
  ResolveBlockDIE(const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  clang::NamespaceDecl *
  ResolveNamespaceDIE(const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  /// Returns the namespace decl that a DW_TAG_imported_declaration imports.
  ///
  /// \param[in] die The import declaration to resolve. If the DIE is not a
  ///                DW_TAG_imported_declaration the behaviour is undefined.
  ///
  /// \returns The decl corresponding to the namespace that the specified
  ///          'die' imports. If the imported entity is not a namespace
  ///          or another import declaration, returns nullptr. If an error
  ///          occurs, returns nullptr.
  clang::NamespaceDecl *ResolveImportedDeclarationDIE(
      const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  bool ParseTemplateDIE(const lldb_private::plugin::dwarf::DWARFDIE &die,
                        lldb_private::TypeSystemClang::TemplateParameterInfos
                            &template_param_infos);
 
  bool ParseTemplateParameterInfos(
      const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
      lldb_private::TypeSystemClang::TemplateParameterInfos
          &template_param_infos);
 
  void GetUniqueTypeNameAndDeclaration(
      const lldb_private::plugin::dwarf::DWARFDIE &die,
      lldb::LanguageType language, lldb_private::ConstString &unique_typename,
      lldb_private::Declaration &decl_declaration);
 
  bool ParseChildMembers(
      const lldb_private::plugin::dwarf::DWARFDIE &die,
      const lldb_private::CompilerType &class_compiler_type,
      std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
      std::vector<lldb_private::plugin::dwarf::DWARFDIE> &member_function_dies,
      std::vector<lldb_private::plugin::dwarf::DWARFDIE> &contained_type_dies,
      DelayedPropertyList &delayed_properties,
      const lldb::AccessType default_accessibility,
      lldb_private::ClangASTImporter::LayoutInfo &layout_info);
 
  void ParseChildParameters(
      clang::DeclContext *containing_decl_ctx,
      const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
      bool &is_variadic, bool &has_template_params,
      std::vector<lldb_private::CompilerType> &function_param_types,
      llvm::SmallVectorImpl<llvm::StringRef> &function_param_names);
 
  size_t ParseChildEnumerators(
      const lldb_private::CompilerType &compiler_type, bool is_signed,
      uint32_t enumerator_byte_size,
      const lldb_private::plugin::dwarf::DWARFDIE &parent_die);
 
  /// Parse a structure, class, or union type DIE.
  lldb::TypeSP
  ParseStructureLikeDIE(const lldb_private::SymbolContext &sc,
                        const lldb_private::plugin::dwarf::DWARFDIE &die,
                        ParsedDWARFTypeAttributes &attrs);
 
  clang::Decl *
  GetClangDeclForDIE(const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  clang::DeclContext *
  GetClangDeclContextForDIE(const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  clang::DeclContext *GetClangDeclContextContainingDIE(
      const lldb_private::plugin::dwarf::DWARFDIE &die,
      lldb_private::plugin::dwarf::DWARFDIE *decl_ctx_die);
  lldb_private::OptionalClangModuleID
  GetOwningClangModule(const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  bool CopyUniqueClassMethodTypes(
      const lldb_private::plugin::dwarf::DWARFDIE &src_class_die,
      const lldb_private::plugin::dwarf::DWARFDIE &dst_class_die,
      lldb_private::Type *class_type,
      std::vector<lldb_private::plugin::dwarf::DWARFDIE> &failures);
 
  clang::DeclContext *GetCachedClangDeclContextForDIE(
      const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  void LinkDeclContextToDIE(clang::DeclContext *decl_ctx,
                            const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  void LinkDeclToDIE(clang::Decl *decl,
                     const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  /// If \p type_sp is valid, calculate and set its symbol context scope, and
  /// update the type list for its backing symbol file.
  ///
  /// Returns \p type_sp.
  lldb::TypeSP UpdateSymbolContextScopeForType(
      const lldb_private::SymbolContext &sc,
      const lldb_private::plugin::dwarf::DWARFDIE &die, lldb::TypeSP type_sp);
 
  /// Follow Clang Module Skeleton CU references to find a type definition.
  lldb::TypeSP
  ParseTypeFromClangModule(const lldb_private::SymbolContext &sc,
                           const lldb_private::plugin::dwarf::DWARFDIE &die,
                           lldb_private::Log *log);
 
  // Return true if this type is a declaration to a type in an external
  // module.
  lldb::ModuleSP
  GetModuleForType(const lldb_private::plugin::dwarf::DWARFDIE &die);
 
private:
  struct FieldInfo {
    /// Size in bits that this field occupies. Can but
    /// need not be the DW_AT_bit_size of the field.
    uint64_t bit_size = 0;
 
    /// Offset of this field in bits from the beginning
    /// of the containing struct. Can but need not
    /// be the DW_AT_data_bit_offset of the field.
    uint64_t bit_offset = 0;
 
    /// In case this field is folded into the storage
    /// of a previous member's storage (for example
    /// with [[no_unique_address]]), the effective field
    /// end is the offset in bits from the beginning of
    /// the containing struct where the field we were
    /// folded into ended.
    std::optional<uint64_t> effective_field_end;
 
    /// Set to 'true' if this field is a bit-field.
    bool is_bitfield = false;
 
    /// Set to 'true' if this field is DW_AT_artificial.
    bool is_artificial = false;
 
    FieldInfo() = default;
 
    void SetIsBitfield(bool flag) { is_bitfield = flag; }
    bool IsBitfield() const { return is_bitfield; }
 
    void SetIsArtificial(bool flag) { is_artificial = flag; }
    bool IsArtificial() const { return is_artificial; }
 
    bool NextBitfieldOffsetIsValid(const uint64_t next_bit_offset) const {
      // Any subsequent bitfields must not overlap and must be at a higher
      // bit offset than any previous bitfield + size.
      return (bit_size + bit_offset) <= next_bit_offset;
    }
 
    /// Returns the offset in bits of where the storage this field
    /// occupies ends.
    uint64_t GetFieldEnd() const { return bit_size + bit_offset; }
 
    void SetEffectiveFieldEnd(uint64_t val) { effective_field_end = val; }
 
    /// If this field was folded into storage of a previous field,
    /// returns the offset in bits of where that storage ends. Otherwise,
    /// returns the regular field end (see \ref GetFieldEnd).
    uint64_t GetEffectiveFieldEnd() const {
      return effective_field_end.value_or(GetFieldEnd());
    }
  };
 
  /// Parsed form of all attributes that are relevant for parsing type members.
  struct MemberAttributes {
    explicit MemberAttributes(
        const lldb_private::plugin::dwarf::DWARFDIE &die,
        const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
        lldb::ModuleSP module_sp);
    const char *name = nullptr;
    /// Indicates how many bits into the word (according to the host endianness)
    /// the low-order bit of the field starts. Can be negative.
    int64_t bit_offset = 0;
    /// Indicates the size of the field in bits.
    size_t bit_size = 0;
    uint64_t data_bit_offset = UINT64_MAX;
    lldb::AccessType accessibility = lldb::eAccessNone;
    std::optional<uint64_t> byte_size;
    std::optional<lldb_private::plugin::dwarf::DWARFFormValue> const_value_form;
    lldb_private::plugin::dwarf::DWARFFormValue encoding_form;
    /// Indicates the byte offset of the word from the base address of the
    /// structure.
    uint32_t member_byte_offset = UINT32_MAX;
    bool is_artificial = false;
    bool is_declaration = false;
  };
 
  /// Returns 'true' if we should create an unnamed bitfield
  /// and add it to the parser's current AST.
  ///
  /// \param[in] last_field_info FieldInfo of the previous DW_TAG_member
  ///            we parsed.
  /// \param[in] last_field_end Offset (in bits) where the last parsed field
  ///            ended.
  /// \param[in] this_field_info FieldInfo of the current DW_TAG_member
  ///            being parsed.
  /// \param[in] layout_info Layout information of all decls parsed by the
  ///            current parser.
  bool ShouldCreateUnnamedBitfield(
      FieldInfo const &last_field_info, uint64_t last_field_end,
      FieldInfo const &this_field_info,
      lldb_private::ClangASTImporter::LayoutInfo const &layout_info) const;
 
  /// Tries to detect whether \ref class_clang_type contained an unnamed
  /// bit-field between \ref previous_field and \ref current_field, and if
  /// so, adds a clang::FieldDecl representing that bit-field to
  /// \ref class_clang_type.
  ///
  /// This is necessary because Clang (and GCC) doesn't emit a DW_TAG_member
  /// entry for unnamed bit-fields. So we derive it (with some exceptions),
  /// by checking whether there is a gap between where the storage of a
  /// DW_TAG_member ended and the subsequent DW_TAG_member began.
  ///
  /// \param[in,out] layout_info Layout information of all decls parsed by the
  ///                            current parser. Will contain an entry for
  ///                            the unnamed bit-field if this function created
  ///                            one.
  ///
  /// \param[in] class_clang_type The RecordType to which the unnamed bit-field
  ///                             will be added (if any).
  ///
  /// \param[in] previous_field FieldInfo of the previous DW_TAG_member
  ///                           we parsed.
  ///
  /// \param[in] current_field FieldInfo of the current DW_TAG_member
  ///                          being parsed.
  ///
  void AddUnnamedBitfieldToRecordTypeIfNeeded(
      lldb_private::ClangASTImporter::LayoutInfo &class_layout_info,
      const lldb_private::CompilerType &class_clang_type,
      const FieldInfo &previous_field, const FieldInfo &current_field);
 
  /// Parses a DW_TAG_APPLE_property DIE and appends the parsed data to the
  /// list of delayed Objective-C properties.
  ///
  /// Note: The delayed property needs to be finalized to actually create the
  /// property declarations in the module AST.
  ///
  /// \param die The DW_TAG_APPLE_property DIE that will be parsed.
  /// \param parent_die The parent DIE.
  /// \param class_clang_type The Objective-C class that will contain the
  /// created property.
  /// \param delayed_properties The list of delayed properties that the result
  /// will be appended to.
  void
  ParseObjCProperty(const lldb_private::plugin::dwarf::DWARFDIE &die,
                    const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
                    const lldb_private::CompilerType &class_clang_type,
                    DelayedPropertyList &delayed_properties);
 
  void
  ParseSingleMember(const lldb_private::plugin::dwarf::DWARFDIE &die,
                    const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
                    const lldb_private::CompilerType &class_clang_type,
                    lldb::AccessType default_accessibility,
                    lldb_private::ClangASTImporter::LayoutInfo &layout_info,
                    FieldInfo &last_field_info);
 
  /// If the specified 'die' represents a static data member, creates
  /// a 'clang::VarDecl' for it and attaches it to specified parent
  /// 'class_clang_type'.
  ///
  /// \param[in] die The member declaration we want to create a
  ///                clang::VarDecl for.
  ///
  /// \param[in] attrs The parsed attributes for the specified 'die'.
  ///
  /// \param[in] class_clang_type The parent RecordType of the static
  ///                             member this function will create.
  void CreateStaticMemberVariable(
      const lldb_private::plugin::dwarf::DWARFDIE &die,
      const MemberAttributes &attrs,
      const lldb_private::CompilerType &class_clang_type);
 
  bool CompleteRecordType(const lldb_private::plugin::dwarf::DWARFDIE &die,
                          const lldb_private::CompilerType &clang_type);
  bool CompleteEnumType(const lldb_private::plugin::dwarf::DWARFDIE &die,
                        lldb_private::Type *type,
                        const lldb_private::CompilerType &clang_type);
 
  lldb::TypeSP
  ParseTypeModifier(const lldb_private::SymbolContext &sc,
                    const lldb_private::plugin::dwarf::DWARFDIE &die,
                    ParsedDWARFTypeAttributes &attrs);
  lldb::TypeSP ParseEnum(const lldb_private::SymbolContext &sc,
                         const lldb_private::plugin::dwarf::DWARFDIE &die,
                         ParsedDWARFTypeAttributes &attrs);
  lldb::TypeSP ParseSubroutine(const lldb_private::plugin::dwarf::DWARFDIE &die,
                               const ParsedDWARFTypeAttributes &attrs);
 
  /// Helper function called by \ref ParseSubroutine when parsing ObjC-methods.
  ///
  /// \param[in] objc_method Name of the ObjC method being parsed.
  ///
  /// \param[in] die The DIE that represents the ObjC method being parsed.
  ///
  /// \param[in] clang_type The CompilerType representing the function prototype
  ///                       of the ObjC method being parsed.
  ///
  /// \param[in] attrs DWARF attributes for \ref die.
  ///
  /// \param[in] is_variadic Is true iff we're parsing a variadic method.
  ///
  /// \returns true on success
  bool
  ParseObjCMethod(const lldb_private::ObjCLanguage::ObjCMethodName &objc_method,
                  const lldb_private::plugin::dwarf::DWARFDIE &die,
                  lldb_private::CompilerType clang_type,
                  const ParsedDWARFTypeAttributes &attrs, bool is_variadic);
 
  /// Helper function called by \ref ParseSubroutine when parsing C++ methods.
  ///
  /// \param[in] die The DIE that represents the C++ method being parsed.
  ///
  /// \param[in] clang_type The CompilerType representing the function prototype
  ///                       of the C++ method being parsed.
  ///
  /// \param[in] attrs DWARF attributes for \ref die.
  ///
  /// \param[in] decl_ctx_die The DIE representing the DeclContext of the C++
  ///                         method being parsed.
  ///
  /// \param[in] object_parameter The DIE of this subprogram's object parameter.
  ///                             May be an invalid DIE for C++ static methods.
  ///
  /// \param[out] ignore_containing_context Will get set to true if the caller
  ///             should treat this C++ method as-if it was not a C++ method.
  ///             Currently used as a hack to work around templated C++ methods
  ///             causing class definitions to mismatch between CUs.
  ///
  /// \returns A pair of <bool, TypeSP>. The first element is 'true' on success.
  ///          The second element is non-null if we have previously parsed this
  ///          method (a null TypeSP does not indicate failure).
  std::pair<bool, lldb::TypeSP>
  ParseCXXMethod(const lldb_private::plugin::dwarf::DWARFDIE &die,
                 lldb_private::CompilerType clang_type,
                 const ParsedDWARFTypeAttributes &attrs,
                 const lldb_private::plugin::dwarf::DWARFDIE &decl_ctx_die,
                 const lldb_private::plugin::dwarf::DWARFDIE &object_parameter,
                 bool &ignore_containing_context);
 
  lldb::TypeSP ParseArrayType(const lldb_private::plugin::dwarf::DWARFDIE &die,
                              const ParsedDWARFTypeAttributes &attrs);
  lldb::TypeSP
  ParsePointerToMemberType(const lldb_private::plugin::dwarf::DWARFDIE &die,
                           const ParsedDWARFTypeAttributes &attrs);
 
  /// Parses a DW_TAG_inheritance DIE into a base/super class.
  ///
  /// \param die The DW_TAG_inheritance DIE to parse.
  /// \param parent_die The parent DIE of the given DIE.
  /// \param class_clang_type The C++/Objective-C class representing parent_die.
  /// For an Objective-C class this method sets the super class on success. For
  /// a C++ class this will *not* add the result as a base class.
  /// \param default_accessibility The default accessibility that is given to
  /// base classes if they don't have an explicit accessibility set.
  /// \param module_sp The current Module.
  /// \param base_classes The list of C++ base classes that will be appended
  /// with the parsed base class on success.
  /// \param layout_info The layout information that will be updated for C++
  /// base classes with the base offset.
  void ParseInheritance(
      const lldb_private::plugin::dwarf::DWARFDIE &die,
      const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
      const lldb_private::CompilerType class_clang_type,
      const lldb::AccessType default_accessibility,
      const lldb::ModuleSP &module_sp,
      std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
      lldb_private::ClangASTImporter::LayoutInfo &layout_info);
 
  /// Parses DW_TAG_variant_part DIE into a structure that encodes all variants
  /// Note that this is currently being emitted by rustc and not Clang
  /// \param die DW_TAG_variant_part DIE to parse
  /// \param parent_die The parent DW_TAG_structure_type to parse
  /// \param class_clang_type The Rust struct representing parent_die.
  /// \param default_accesibility The default accessibility that is given to
  ///  base classes if they don't have an explicit accessibility set
  /// \param layout_info The layout information that will be updated for
  //   base classes with the base offset
  void
  ParseRustVariantPart(lldb_private::plugin::dwarf::DWARFDIE &die,
                       const lldb_private::plugin::dwarf::DWARFDIE &parent_die,
                       const lldb_private::CompilerType &class_clang_type,
                       const lldb::AccessType default_accesibility,
                       lldb_private::ClangASTImporter::LayoutInfo &layout_info);
};
 
/// Parsed form of all attributes that are relevant for type reconstruction.
/// Some attributes are relevant for all kinds of types (declaration), while
/// others are only meaningful to a specific type (is_virtual)
struct ParsedDWARFTypeAttributes {
  explicit ParsedDWARFTypeAttributes(
      const lldb_private::plugin::dwarf::DWARFDIE &die);
 
  lldb::AccessType accessibility = lldb::eAccessNone;
  bool is_artificial = false;
  bool is_complete_objc_class = false;
  bool is_explicit = false;
  bool is_forward_declaration = false;
  bool is_inline = false;
  bool is_scoped_enum = false;
  bool is_vector = false;
  bool is_virtual = false;
  bool is_objc_direct_call = false;
  bool exports_symbols = false;
  clang::StorageClass storage = clang::SC_None;
  const char *mangled_name = nullptr;
  lldb_private::ConstString name;
  lldb_private::Declaration decl;
  lldb_private::plugin::dwarf::DWARFFormValue abstract_origin;
  lldb_private::plugin::dwarf::DWARFFormValue containing_type;
  lldb_private::plugin::dwarf::DWARFFormValue signature;
  lldb_private::plugin::dwarf::DWARFFormValue specification;
  lldb_private::plugin::dwarf::DWARFFormValue type;
  lldb::LanguageType class_language = lldb::eLanguageTypeUnknown;
  std::optional<uint64_t> byte_size;
  std::optional<uint64_t> data_bit_size;
  std::optional<uint64_t> alignment;
  size_t calling_convention = llvm::dwarf::DW_CC_normal;
  uint32_t bit_stride = 0;
  uint32_t byte_stride = 0;
  uint32_t encoding = 0;
 
  ///< Indicates ref-qualifier of C++ member function if present.
  ///< Is RQ_None otherwise.
  clang::RefQualifierKind ref_qual = clang::RQ_None;
 
  ///< Has a value if this DIE represents an enum that was declared
  ///< with enum_extensibility.
  std::optional<clang::EnumExtensibilityAttr::Kind> enum_kind;
};
 
#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H