[lldb] Generalize ParsedDWARFTypeAttributes

[ljmf00]

Summary

This patch generalizes the ParsedDWARFTypeAttributes struct to be able to share with other DWARF parsers other than clang. This patch also reduces the memory footprint of the struct by using bit flags instead of individual booleans.

[ljmf00]

I'm not sure if this falls into NFC category since I'm changing how flags are stored.

[labath]

I don't think we should be putting this into the DWARFAttribute file. It is substantially higher-level than the rest of the file, and the DWARFAttribute file is destined to be merged with the llvm implementation at some point. Is there a reason for not putting it into DWARFASTParser (like the other patch)?

In D114746#3160331, @ljmf00 wrote:

I'm not sure if this falls into NFC category since I'm changing how flags are stored.

There's no formal definition of "NFC", so it does not really matter.

This patch also reduces the memory footprint of the struct by using bit flags instead of individual booleans.

The class was never meant to be stored anywhere else except the stack of the function doing the parsing, so it's not really necessary to optimize it that much. But since, you've already done it, I suppose it can stay...

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

83

This macro was created specifically for using in lldb public api. Elsewhere you can just use the standard llvm solution (search for LLVM_MARK_AS_BITMASK_ENUM).

Since this attribute is not supposed to be visible/useful outside the ParsedDWARFTypeAttributes class, I think it'd be better to declare it there.

123

inline on a method declared inside the class is redundant

[ljmf00]

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

86

I forgot to add the rest of the documentation. Leaving a note here for myself

[shafik]

I also echo Pavel's question, why not in DWARFASTParser?

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

1139–1140

Is there a reason not to use an attribute storage like before? This feels like we are leaking out of the abstraction where before we were not.

1492

if we are going to have getter abstraction why not have a setIsForwardDeclaration() or something similar.

[ljmf00]

In D114746#3160908, @labath wrote:

I don't think we should be putting this into the DWARFAttribute file. It is substantially higher-level than the rest of the file, and the DWARFAttribute file is destined to be merged with the llvm implementation at some point. Is there a reason for not putting it into DWARFASTParser (like the other patch)?

I changed to DWARFASTParser. There was no particular reason other than naming, but since I lack some knowledge about the overall infrastructure I was not sure.

In D114746#3160331, @ljmf00 wrote:

I'm not sure if this falls into NFC category since I'm changing how flags are stored.

There's no formal definition of "NFC", so it does not really matter.

Oh ok. I read it on the Developers Policy glossary, so I was not sure. Thanks for the clarification.

This patch also reduces the memory footprint of the struct by using bit flags instead of individual booleans.

The class was never meant to be stored anywhere else except the stack of the function doing the parsing, so it's not really necessary to optimize it that much. But since, you've already done it, I suppose it can stay...

Well, I didn't make any performance tests but it surely can improve memory usage. I guess the compiler can also be smart if the memory is only on the stack.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

1139–1140

I think the abstraction of the external attribute is valid since storage is Clang specific StorageClass.

1492

Yeah, I can see the improvement, I added setters too. I didn't add them since the set was only used as a statement rather than an expression.

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

86

Added documentation.

[ljmf00]

Ops, clicked on the wrong button

[shafik]

I am happy as long as Pavel is good.

[labath]

I can't help the feeling that the boilerplate introduced by the enum compression is just not worth the benefit it brings, but otherwise this looks ok apart from the two inline comments.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

90

What's up with this?

I would hope that clang-format is able to reasonably format a simple enum declaration like this.

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

12–16

revert this.

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

 //===-- DWARFASTParser.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_DWARFASTPARSER_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSER_H
 
+#include "DWARFDIE.h"
 #include "DWARFDefines.h"
+#include "DWARFFormValue.h"
+#include "lldb/Core/Declaration.h"
+#include "lldb/Utility/ConstString.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-enumerations.h"
 
 class DWARFDIE;
 namespace lldb_private {
public:
 
   static llvm::Optional<lldb_private::SymbolFile::ArrayInfo>
   ParseChildArrayInfo(const DWARFDIE &parent_die,
                       const lldb_private::ExecutionContext *exe_ctx = nullptr);
 
   static lldb::AccessType GetAccessTypeFromDWARF(uint32_t dwarf_accessibility);
 };
 
+/// 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 DWARFDIE &die);
+
+  lldb::AccessType accessibility = lldb::eAccessNone;
+  const char *mangled_name = nullptr;
+  lldb_private::ConstString name;
+  lldb_private::Declaration decl;
+  DWARFDIE object_pointer;
+  DWARFFormValue abstract_origin;
+  DWARFFormValue containing_type;
+  DWARFFormValue signature;
+  DWARFFormValue specification;
+  DWARFFormValue type;
+  lldb::LanguageType class_language = lldb::eLanguageTypeUnknown;
+  llvm::Optional<uint64_t> byte_size;
+  size_t calling_convention = llvm::dwarf::DW_CC_normal;
+  uint32_t bit_stride = 0;
+  uint32_t byte_stride = 0;
+  uint32_t encoding = 0;
+  uint32_t attr_flags = 0;
+
+  // clang-format off
+  enum DWARFAttributeFlags : unsigned {
+    /// Represents no attributes.
+    eDWARFAttributeNone             = 0u,
+    /// Whether it is an artificially generated symbol.
+    eDWARFAttributeArtificial       = 1u << 0,
+    /// Whether it has explicit property of member function.
+    eDWARFAttributeExplicit         = 1u << 1,
+    /// Whether it is a forward declaration.
+    eDWARFAttributeForwardDecl      = 1u << 2,
+    /// Whether it is an inlined symbol.
+    eDWARFAttributeInline           = 1u << 3,
+    /// Whether it is a scoped enumeration (class enum).
+    eDWARFAttributeScopedEnum       = 1u << 4,
+    /// Whether it has vector attribute.
+    eDWARFAttributeVector           = 1u << 5,
+    /// Whether it has virtuality attribute.
+    eDWARFAttributeVirtual          = 1u << 6,
+    /// Whether it is an external symbol.
+    eDWARFAttributeExternal         = 1u << 7,
+    /// Whether it export symbols to the containing scope.
+    eDWARFAttributeExportSymbols    = 1u << 8,
+    /// Whether it is an Objective-C direct call.
+    eDWARFAttributeObjCDirect       = 1u << 9,
+    /// Whether it is an Objective-C complete type.
+    eDWARFAttributeObjCCompleteType = 1u << 10,
+    LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/eDWARFAttributeObjCCompleteType),
+  };
+  // clang-format on
+
+  void setIsArtificial() {
+    attr_flags |= eDWARFAttributeArtificial;
+  }
+  bool isArtificial() const {
+    return attr_flags & eDWARFAttributeArtificial;
+  }
+
+  void setIsExplicit() {
+    attr_flags |= eDWARFAttributeExplicit;
+  }
+  bool isExplicit() const {
+    return attr_flags & eDWARFAttributeExplicit;
+  }
+
+  void setIsForwardDeclaration() {
+    attr_flags |= eDWARFAttributeForwardDecl;
+  }
+  bool isForwardDeclaration() const {
+    return attr_flags & eDWARFAttributeForwardDecl;
+  }
+
+  void setIsInline() {
+    attr_flags |= eDWARFAttributeInline;
+  }
+  bool isInline() const {
+    return attr_flags & eDWARFAttributeInline;
+  }
+
+  void setIsScopedEnum() {
+    attr_flags |= eDWARFAttributeScopedEnum;
+  }
+  bool isScopedEnum() const {
+    return attr_flags & eDWARFAttributeScopedEnum;
+  }
+
+  void setIsVector() {
+    attr_flags |= eDWARFAttributeVector;
+  }
+  bool isVector() const {
+    return attr_flags & eDWARFAttributeVector;
+  }
+
+  void setIsVirtual() {
+    attr_flags |= eDWARFAttributeVirtual;
+  }
+  bool isVirtual() const {
+    return attr_flags & eDWARFAttributeVirtual;
+  }
+
+  void setIsExternal() {
+    attr_flags |= eDWARFAttributeExternal;
+  }
+  bool isExternal() const {
+    return attr_flags & eDWARFAttributeExternal;
+  }
+
+  void setIsExportsSymbols() {
+    attr_flags |= eDWARFAttributeExportSymbols;
+  }
+  bool isExportsSymbols() const {
+    return attr_flags & eDWARFAttributeExportSymbols;
+  }
+
+  void setIsObjCDirectCall() {
+    attr_flags |= eDWARFAttributeObjCDirect;
+  }
+  bool isObjCDirectCall() const {
+    return attr_flags & eDWARFAttributeObjCDirect;
+  }
+
+  void setIsObjCCompleteType() {
+    attr_flags |= eDWARFAttributeObjCCompleteType;
+  }
+  bool isObjCCompleteType() const {
+    return attr_flags & eDWARFAttributeObjCCompleteType;
+  }
+};
+
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSER_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.cpp

 //===-- DWARFASTParser.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 "DWARFASTParser.h"
 #include "DWARFAttribute.h"
 #include "DWARFDIE.h"
+#include "DWARFUnit.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/StackFrame.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
case DW_ACCESS_private:
     return eAccessPrivate;
   case DW_ACCESS_protected:
     return eAccessProtected;
   default:
     break;
   }
   return eAccessNone;
 }
+
+ParsedDWARFTypeAttributes::ParsedDWARFTypeAttributes(const DWARFDIE &die) {
+  DWARFAttributes attributes;
+  size_t num_attributes = die.GetAttributes(attributes);
+  for (size_t i = 0; i < num_attributes; ++i) {
+    dw_attr_t attr = attributes.AttributeAtIndex(i);
+    DWARFFormValue form_value;
+    if (!attributes.ExtractFormValueAtIndex(i, form_value))
+      continue;
+    switch (attr) {
+    case DW_AT_abstract_origin:
+      abstract_origin = form_value;
+      break;
+
+    case DW_AT_accessibility:
+      accessibility = DWARFASTParser::GetAccessTypeFromDWARF(form_value.Unsigned());
+      break;
+
+    case DW_AT_artificial:
+      if (form_value.Boolean())
+        setIsArtificial();
+      break;
+
+    case DW_AT_bit_stride:
+      bit_stride = form_value.Unsigned();
+      break;
+
+    case DW_AT_byte_size:
+      byte_size = form_value.Unsigned();
+      break;
+
+    case DW_AT_byte_stride:
+      byte_stride = form_value.Unsigned();
+      break;
+
+    case DW_AT_calling_convention:
+      calling_convention = form_value.Unsigned();
+      break;
+
+    case DW_AT_containing_type:
+      containing_type = form_value;
+      break;
+
+    case DW_AT_decl_file:
+      // die.GetCU() can differ if DW_AT_specification uses DW_FORM_ref_addr.
+      decl.SetFile(
+          attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned()));
+      break;
+    case DW_AT_decl_line:
+      decl.SetLine(form_value.Unsigned());
+      break;
+    case DW_AT_decl_column:
+      decl.SetColumn(form_value.Unsigned());
+      break;
+
+    case DW_AT_declaration:
+      if (form_value.Boolean())
+        setIsForwardDeclaration();
+      break;
+
+    case DW_AT_encoding:
+      encoding = form_value.Unsigned();
+      break;
+
+    case DW_AT_enum_class:
+      if (form_value.Boolean())
+        setIsScopedEnum();
+      break;
+
+    case DW_AT_explicit:
+      if (form_value.Boolean())
+        setIsExplicit();
+      break;
+
+    case DW_AT_external:
+      if (form_value.Unsigned())
+        setIsExternal();
+      break;
+
+    case DW_AT_inline:
+      if (form_value.Boolean())
+        setIsInline();
+      break;
+
+    case DW_AT_linkage_name:
+    case DW_AT_MIPS_linkage_name:
+      mangled_name = form_value.AsCString();
+      break;
+
+    case DW_AT_name:
+      name.SetCString(form_value.AsCString());
+      break;
+
+    case DW_AT_object_pointer:
+      object_pointer = form_value.Reference();
+      break;
+
+    case DW_AT_signature:
+      signature = form_value;
+      break;
+
+    case DW_AT_specification:
+      specification = form_value;
+      break;
+
+    case DW_AT_type:
+      type = form_value;
+      break;
+
+    case DW_AT_virtuality:
+      if (form_value.Unsigned())
+        setIsVirtual();
+      break;
+
+    case DW_AT_APPLE_objc_complete_type:
+      if (form_value.Signed())
+        setIsObjCCompleteType();
+      break;
+
+    case DW_AT_APPLE_objc_direct:
+      setIsObjCDirectCall();
+      break;
+
+    case DW_AT_APPLE_runtime_class:
+      class_language = (LanguageType)form_value.Signed();
+      break;
+
+    case DW_AT_GNU_vector:
+      if (form_value.Boolean())
+        setIsVector();
+      break;
+    case DW_AT_export_symbols:
+      if (form_value.Boolean())
+        setIsExportsSymbols();
+      break;
+    }
+  }
+}

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

void ParseInheritance(
       const DWARFDIE &die, const 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);
 };
 
-/// 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 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;
-  DWARFDIE object_pointer;
-  DWARFFormValue abstract_origin;
-  DWARFFormValue containing_type;
-  DWARFFormValue signature;
-  DWARFFormValue specification;
-  DWARFFormValue type;
-  lldb::LanguageType class_language = lldb::eLanguageTypeUnknown;
-  llvm::Optional<uint64_t> byte_size;
-  size_t calling_convention = llvm::dwarf::DW_CC_normal;
-  uint32_t bit_stride = 0;
-  uint32_t byte_stride = 0;
-  uint32_t encoding = 0;
-};
-
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

die.GetDWARF()->GetObjectFile()->GetModule()->ReportError(
         type_name_cstr ? type_name_cstr : "", die.GetOffset());
   }
 
   // We don't have a type definition and/or the import failed. We must
   // forcefully complete the type to avoid crashes.
   ForcefullyCompleteType(type);
 }
 
-ParsedDWARFTypeAttributes::ParsedDWARFTypeAttributes(const DWARFDIE &die) {
-  DWARFAttributes attributes;
-  size_t num_attributes = die.GetAttributes(attributes);
-  for (size_t i = 0; i < num_attributes; ++i) {
-    dw_attr_t attr = attributes.AttributeAtIndex(i);
-    DWARFFormValue form_value;
-    if (!attributes.ExtractFormValueAtIndex(i, form_value))
-      continue;
-    switch (attr) {
-    case DW_AT_abstract_origin:
-      abstract_origin = form_value;
-      break;
-
-    case DW_AT_accessibility:
-      accessibility = DWARFASTParser::GetAccessTypeFromDWARF(form_value.Unsigned());
-      break;
-
-    case DW_AT_artificial:
-      is_artificial = form_value.Boolean();
-      break;
-
-    case DW_AT_bit_stride:
-      bit_stride = form_value.Unsigned();
-      break;
-
-    case DW_AT_byte_size:
-      byte_size = form_value.Unsigned();
-      break;
-
-    case DW_AT_byte_stride:
-      byte_stride = form_value.Unsigned();
-      break;
-
-    case DW_AT_calling_convention:
-      calling_convention = form_value.Unsigned();
-      break;
-
-    case DW_AT_containing_type:
-      containing_type = form_value;
-      break;
-
-    case DW_AT_decl_file:
-      // die.GetCU() can differ if DW_AT_specification uses DW_FORM_ref_addr.
-      decl.SetFile(
-          attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned()));
-      break;
-    case DW_AT_decl_line:
-      decl.SetLine(form_value.Unsigned());
-      break;
-    case DW_AT_decl_column:
-      decl.SetColumn(form_value.Unsigned());
-      break;
-
-    case DW_AT_declaration:
-      is_forward_declaration = form_value.Boolean();
-      break;
-
-    case DW_AT_encoding:
-      encoding = form_value.Unsigned();
-      break;
-
-    case DW_AT_enum_class:
-      is_scoped_enum = form_value.Boolean();
-      break;
-
-    case DW_AT_explicit:
-      is_explicit = form_value.Boolean();
-      break;
-
-    case DW_AT_external:
-      if (form_value.Unsigned())
-        storage = clang::SC_Extern;
-      break;
-
-    case DW_AT_inline:
-      is_inline = form_value.Boolean();
-      break;
-
-    case DW_AT_linkage_name:
-    case DW_AT_MIPS_linkage_name:
-      mangled_name = form_value.AsCString();
-      break;
-
-    case DW_AT_name:
-      name.SetCString(form_value.AsCString());
-      break;
-
-    case DW_AT_object_pointer:
-      object_pointer = form_value.Reference();
-      break;
-
-    case DW_AT_signature:
-      signature = form_value;
-      break;
-
-    case DW_AT_specification:
-      specification = form_value;
-      break;
-
-    case DW_AT_type:
-      type = form_value;
-      break;
-
-    case DW_AT_virtuality:
-      is_virtual = form_value.Boolean();
-      break;
-
-    case DW_AT_APPLE_objc_complete_type:
-      is_complete_objc_class = form_value.Signed();
-      break;
-
-    case DW_AT_APPLE_objc_direct:
-      is_objc_direct_call = true;
-      break;
-
-    case DW_AT_APPLE_runtime_class:
-      class_language = (LanguageType)form_value.Signed();
-      break;
-
-    case DW_AT_GNU_vector:
-      is_vector = form_value.Boolean();
-      break;
-    case DW_AT_export_symbols:
-      exports_symbols = form_value.Boolean();
-      break;
-    }
-  }
-}
-
 static std::string GetUnitName(const DWARFDIE &die) {
   if (DWARFUnit *unit = die.GetCU())
     return unit->GetAbsolutePath().GetPath();
   return "<missing DWARF unit path>";
 }
 
 TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
                                                const DWARFDIE &die,
TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
                                       const DWARFDIE &die,
                                       ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
   SymbolFileDWARF *dwarf = die.GetDWARF();
   const dw_tag_t tag = die.Tag();
   TypeSP type_sp;
 
-  if (attrs.is_forward_declaration) {
+  if (attrs.isForwardDeclaration()) {
     type_sp = ParseTypeFromClangModule(sc, die, log);
     if (type_sp)
       return type_sp;
 
     DWARFDeclContext die_decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
 
     type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
 
if (!enumerator_clang_type) {
         enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt);
       }
     }
 
     clang_type = m_ast.CreateEnumerationType(
         attrs.name.GetStringRef(),
         GetClangDeclContextContainingDIE(die, nullptr),
         GetOwningClangModule(die), attrs.decl, enumerator_clang_type,
-        attrs.is_scoped_enum);
+        attrs.isScopedEnum());
   } else {
     enumerator_clang_type = m_ast.GetEnumerationIntegerType(clang_type);
   }
 
   LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type), die);
 
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
           // If accessibility isn't set to anything valid, assume public
           // for now...
           if (attrs.accessibility == eAccessNone)
             attrs.accessibility = eAccessPublic;
 
           clang::ObjCMethodDecl *objc_method_decl =
               m_ast.AddMethodToObjCObjectType(
                   class_opaque_type, attrs.name.GetCString(), clang_type,
-                  attrs.accessibility, attrs.is_artificial, is_variadic,
-                  attrs.is_objc_direct_call);
+                  attrs.accessibility, attrs.isArtificial(), is_variadic,
+                  attrs.isObjCDirectCall());
           type_handled = objc_method_decl != NULL;
           if (type_handled) {
             LinkDeclContextToDIE(objc_method_decl, die);
             m_ast.SetMetadataAsUserID(objc_method_decl, die.GetID());
           } else {
             dwarf->GetObjectFile()->GetModule()->ReportError(
                 "{0x%8.8x}: invalid Objective-C method 0x%4.4x (%s), "
                 "please file a bug and attach the file at the start of "
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                     // Default to public for now...
                     if (attrs.accessibility == eAccessNone)
                       attrs.accessibility = eAccessPublic;
 
                     clang::CXXMethodDecl *cxx_method_decl =
                         m_ast.AddMethodToCXXRecordType(
                             class_opaque_type.GetOpaqueQualType(),
                             attrs.name.GetCString(), attrs.mangled_name,
-                            clang_type, attrs.accessibility, attrs.is_virtual,
-                            is_static, attrs.is_inline, attrs.is_explicit,
-                            is_attr_used, attrs.is_artificial);
+                            clang_type, attrs.accessibility, attrs.isVirtual(),
+                            is_static, attrs.isInline(), attrs.isExplicit(),
+                            is_attr_used, attrs.isArtificial());
 
                     type_handled = cxx_method_decl != NULL;
                     // Artificial methods are always handled even when we
                     // don't create a new declaration for them.
-                    type_handled |= attrs.is_artificial;
+                    type_handled |= attrs.isArtificial();
 
                     if (cxx_method_decl) {
                       LinkDeclContextToDIE(cxx_method_decl, die);
 
                       ClangASTMetadata metadata;
                       metadata.SetUserID(die.GetID());
 
                       if (!object_pointer_name.empty()) {
if (!type_handled) {
             name = name_buf;
           }
         }
 
         // We just have a function that isn't part of a class
         function_decl = m_ast.CreateFunctionDeclaration(
             ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                       : containing_decl_ctx,
-            GetOwningClangModule(die), name, clang_type, attrs.storage,
-            attrs.is_inline);
+            GetOwningClangModule(die), name, clang_type, attrs.isExternal() ? clang::SC_Extern : clang::SC_None,
+            attrs.isInline());
         std::free(name_buf);
 
         if (has_template_params) {
           TypeSystemClang::TemplateParameterInfos template_param_infos;
           ParseTemplateParameterInfos(die, template_param_infos);
           template_function_decl = m_ast.CreateFunctionDeclaration(
               ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                         : containing_decl_ctx,
               GetOwningClangModule(die), attrs.name.GetStringRef(), clang_type,
-              attrs.storage, attrs.is_inline);
+              attrs.isExternal() ? clang::SC_Extern : clang::SC_None, attrs.isInline());
           clang::FunctionTemplateDecl *func_template_decl =
               m_ast.CreateFunctionTemplateDecl(
                   containing_decl_ctx, GetOwningClangModule(die),
                   template_function_decl, template_param_infos);
           m_ast.CreateFunctionTemplateSpecializationInfo(
               template_function_decl, func_template_decl, template_param_infos);
         }
 
uint64_t array_element_bit_stride =
       attrs.byte_stride * 8 + attrs.bit_stride;
   CompilerType clang_type;
   if (array_info && array_info->element_orders.size() > 0) {
     uint64_t num_elements = 0;
     auto end = array_info->element_orders.rend();
     for (auto pos = array_info->element_orders.rbegin(); pos != end; ++pos) {
       num_elements = *pos;
       clang_type = m_ast.CreateArrayType(array_element_type, num_elements,
-                                         attrs.is_vector);
+                                         attrs.isVector());
       array_element_type = clang_type;
       array_element_bit_stride = num_elements
                                      ? array_element_bit_stride * num_elements
                                      : array_element_bit_stride;
     }
   } else {
     clang_type =
-        m_ast.CreateArrayType(array_element_type, 0, attrs.is_vector);
+        m_ast.CreateArrayType(array_element_type, 0, attrs.isVector());
   }
   ConstString empty_name;
   TypeSP type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, empty_name, array_element_bit_stride / 8, nullptr,
       dwarf->GetUID(type_die), Type::eEncodingIsUID, &attrs.decl, clang_type,
       Type::ResolveState::Full);
   type_sp->SetEncodingType(element_type);
   const clang::Type *type = ClangUtil::GetQualType(clang_type).getTypePtr();
if (attrs.byte_size && *attrs.byte_size == 0 && attrs.name &&
     //  DW_TAG_structure_type [2]
     //  DW_AT_name( "ForwardObjcClass" )
     //  DW_AT_byte_size( 0x00 )
     //  DW_AT_decl_file( "..." )
     //  DW_AT_decl_line( 1 )
     //
     // Note that there is no DW_AT_declaration and there are no children,
     // and the byte size is zero.
-    attrs.is_forward_declaration = true;
+    attrs.setIsForwardDeclaration();
   }
 
   if (attrs.class_language == eLanguageTypeObjC ||
       attrs.class_language == eLanguageTypeObjC_plus_plus) {
-    if (!attrs.is_complete_objc_class &&
+    if (!attrs.isObjCCompleteType() &&
         die.Supports_DW_AT_APPLE_objc_complete_type()) {
       // We have a valid eSymbolTypeObjCClass class symbol whose name
       // matches the current objective C class that we are trying to find
       // and this DIE isn't the complete definition (we checked
       // is_complete_objc_class above and know it is false), so the real
       // definition is in here somewhere
       type_sp =
           dwarf->FindCompleteObjCDefinitionTypeForDIE(die, attrs.name, true);
if (!attrs.isObjCCompleteType() &&
         // it and cache the fact that we found a complete type for this
         // die
         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
         return type_sp;
       }
     }
   }
 
-  if (attrs.is_forward_declaration) {
+  if (attrs.isForwardDeclaration()) {
     // We have a forward declaration to a type and we need to try and
     // find a full declaration. We look in the current type index just in
     // case we have a forward declaration followed by an actual
     // declarations in the DWARF. If this fails, we need to look
     // elsewhere...
     if (log) {
       dwarf->GetObjectFile()->GetModule()->LogMessage(
           log,
if (attrs.name.GetStringRef().contains('<')) {
       }
     }
 
     if (!clang_type_was_created) {
       clang_type_was_created = true;
       clang_type = m_ast.CreateRecordType(
           decl_ctx, GetOwningClangModule(die), attrs.accessibility,
           attrs.name.GetCString(), tag_decl_kind, attrs.class_language,
-          &metadata, attrs.exports_symbols);
+          &metadata, attrs.isExportsSymbols());
     }
   }
 
   // Store a forward declaration to this class type in case any
   // parameters in any class methods need it for the clang types for
   // function prototypes.
   LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
       LLDB_INVALID_UID, Type::eEncodingIsUID, &attrs.decl, clang_type,
       Type::ResolveState::Forward,
-      TypePayloadClang(OptionalClangModuleID(), attrs.is_complete_objc_class));
+      TypePayloadClang(OptionalClangModuleID(), attrs.isObjCCompleteType()));
 
   // Add our type to the unique type map so we don't end up creating many
   // copies of the same type over and over in the ASTContext for our
   // module
   unique_ast_entry_up->m_type_sp = type_sp;
   unique_ast_entry_up->m_die = die;
   unique_ast_entry_up->m_declaration = unique_decl;
   unique_ast_entry_up->m_byte_size = attrs.byte_size.getValueOr(0);
   dwarf->GetUniqueDWARFASTTypeMap().Insert(unique_typename,
                                            *unique_ast_entry_up);
 
-  if (!attrs.is_forward_declaration) {
+  if (!attrs.isForwardDeclaration()) {
     // Always start the definition for a class type so that if the class
     // has child classes or types that require the class to be created
     // for use as their decl contexts the class will be ready to accept
     // these child definitions.
     if (!die.HasChildren()) {
       // No children for this struct/union/class, lets finish it
       if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
         TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

 //===-- DWARFAttribute.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_DWARFATTRIBUTE_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFATTRIBUTE_H
 
+#include "DWARFDIE.h"
 #include "DWARFDefines.h"
 #include "DWARFFormValue.h"
+#include "lldb/Core/Declaration.h"
+#include "lldb/Utility/ConstString.h"
 #include "llvm/ADT/SmallVector.h"
 #include <vector>
 
 class DWARFUnit;
 
 class DWARFAttribute {
 public:
   DWARFAttribute(dw_attr_t attr, dw_form_t form,
DWARFUnit *cu; // Keep the compile unit with each attribute in
                    // case we have DW_FORM_ref_addr values
     dw_offset_t die_offset;
     DWARFAttribute attr;
   };
   typedef llvm::SmallVector<AttributeValue, 8> collection;
   collection m_infos;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFATTRIBUTE_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp

 //===-- DWARFAttribute.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 "DWARFAttribute.h"
 #include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 
+using namespace lldb;
+
 DWARFAttributes::DWARFAttributes() : m_infos() {}
 
 DWARFAttributes::~DWARFAttributes() = default;
 
 uint32_t DWARFAttributes::FindAttributeIndex(dw_attr_t attr) const {
   collection::const_iterator end = m_infos.end();
   collection::const_iterator beg = m_infos.begin();
   collection::const_iterator pos;