Make dw_tag_t a llvm::dwarf::Tag

[JDevlieghere]

Summary

When talking to Shafik about D67994, we discovered that dw_tag_t is a typedef for uint16_t. I believe it would be better to typedef it to llvm::dwarf::Tag instead, so we can use the full power of the DWARF utilities in LLVM without having to do the cast. With this approach, we only have to do the cast when reading the ULEB value.

[labath]

Makes sense to me.

[aprantl]

lldb/trunk/include/lldb/Core/dwarf.h

23 ↗

(On Diff #221783)

so should this be llvm::dwarf::Attribute?

24 ↗

(On Diff #221783)

llvm::dwarf::Form?

[shafik]

Thanks for doing this! I spent a bunch of time trying to understand that relationship yesterday.

lldb/include/lldb/Core/dwarf.h

 
 // and stuff them in our default namespace
 using namespace llvm::dwarf;
 
 typedef uint32_t dw_uleb128_t;
 typedef int32_t dw_sleb128_t;
 typedef uint16_t dw_attr_t;
 typedef uint16_t dw_form_t;
-typedef uint16_t dw_tag_t;
+typedef llvm::dwarf::Tag dw_tag_t;
 typedef uint64_t dw_addr_t; // Dwarf address define that must be big enough for
                             // any addresses in the compile units that get
                             // parsed
 
 typedef uint32_t dw_offset_t; // Dwarf Debug Information Entry offset for any
                               // offset into the file
 
 /* Constants */

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

 
 #include "llvm/Object/Error.h"
 
 #include "DWARFFormValue.h"
 
 using namespace lldb_private;
 
 DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration()
-    : m_code(InvalidCode), m_tag(0), m_has_children(0), m_attributes() {}
+    : m_code(InvalidCode), m_tag(llvm::dwarf::DW_TAG_null), m_has_children(0),
+      m_attributes() {}
 
 DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration(dw_tag_t tag,
                                                            uint8_t has_children)
     : m_code(InvalidCode), m_tag(tag), m_has_children(has_children),
       m_attributes() {}
 
 llvm::Expected<DWARFEnumState>
 DWARFAbbreviationDeclaration::extract(const DWARFDataExtractor &data,
                                       lldb::offset_t *offset_ptr) {
   m_code = data.GetULEB128(offset_ptr);
   if (m_code == 0)
     return DWARFEnumState::Complete;
 
   m_attributes.clear();
-  m_tag = data.GetULEB128(offset_ptr);
+  m_tag = static_cast<dw_tag_t>(data.GetULEB128(offset_ptr));
   if (m_tag == DW_TAG_null)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "abbrev decl requires non-null tag.");
 
   m_has_children = data.GetU8(offset_ptr);
 
   while (data.ValidOffset(*offset_ptr)) {
     dw_attr_t attr = data.GetULEB128(offset_ptr);
DWARFAbbreviationDeclaration::extract(const DWARFDataExtractor &data,
   }
 
   return llvm::make_error<llvm::object::GenericBinaryError>(
       "abbreviation declaration attribute list not terminated with a null "
       "entry");
 }
 
 bool DWARFAbbreviationDeclaration::IsValid() {
-  return m_code != 0 && m_tag != 0;
+  return m_code != 0 && m_tag != llvm::dwarf::DW_TAG_null;
 }
 
 uint32_t
 DWARFAbbreviationDeclaration::FindAttributeIndex(dw_attr_t attr) const {
   uint32_t i;
   const uint32_t kNumAttributes = m_attributes.size();
   for (i = 0; i < kNumAttributes; ++i) {
     if (m_attributes[i].get_attr() == attr)

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

llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef() const {
   return DIERef(m_cu->GetSymbolFileDWARF().GetDwoNum(), m_cu->GetDebugSection(),
                 m_die->GetOffset());
 }
 
 dw_tag_t DWARFBaseDIE::Tag() const {
   if (m_die)
     return m_die->Tag();
   else
-    return 0;
+    return llvm::dwarf::DW_TAG_null;
 }
 
 const char *DWARFBaseDIE::GetTagAsCString() const {
   return lldb_private::DW_TAG_value_to_name(Tag());
 }
 
 const char *DWARFBaseDIE::GetAttributeValueAsString(const dw_attr_t attr,
                                                 const char *fail_value) const {

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

 class DWARFDebugInfoEntry {
 public:
   typedef std::vector<DWARFDebugInfoEntry> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   DWARFDebugInfoEntry()
       : m_offset(DW_INVALID_OFFSET), m_parent_idx(0), m_sibling_idx(0),
-        m_has_children(false), m_abbr_idx(0), m_tag(0) {}
+        m_has_children(false), m_abbr_idx(0), m_tag(llvm::dwarf::DW_TAG_null) {}
 
   explicit operator bool() const { return m_offset != DW_INVALID_OFFSET; }
   bool operator==(const DWARFDebugInfoEntry &rhs) const;
   bool operator!=(const DWARFDebugInfoEntry &rhs) const;
 
   void BuildAddressRangeTable(const DWARFUnit *cu,
                               DWARFDebugAranges *debug_aranges) const;
 
protected:
   uint32_t m_parent_idx; // How many to subtract from "this" to get the parent.
                          // If zero this die has no parent
   uint32_t m_sibling_idx : 31, // How many to add to "this" to get the sibling.
       // If it is zero, then the DIE doesn't have children, or the
       // DWARF claimed it had children but the DIE only contained
       // a single NULL terminating child.
       m_has_children : 1;
   uint16_t m_abbr_idx;
-  uint16_t m_tag; // A copy of the DW_TAG value so we don't have to go through
-                  // the compile unit abbrev table
+  /// A copy of the DW_TAG value so we don't have to go through the compile
+  /// unit abbrev table
+  dw_tag_t m_tag = llvm::dwarf::DW_TAG_null;
 };
 
 #endif // SymbolFileDWARF_DWARFDebugInfoEntry_h_

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

for (i = 0; i < numAttributes; ++i) {
           offset += form_size;
 
         } while (form_is_indirect);
       }
     }
     *offset_ptr = offset;
     return true;
   } else {
-    m_tag = 0;
+    m_tag = llvm::dwarf::DW_TAG_null;
     m_has_children = false;
     return true; // NULL debug tag entry
   }
 
   return false;
 }
 
 static DWARFRangeList GetRangesOrReportError(const DWARFUnit &unit,

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

 //
 // A class that represents a declaration context all the way down to a
 // DIE. This is useful when trying to find a DIE in one DWARF to a DIE
 // in another DWARF file.
 
 class DWARFDeclContext {
 public:
   struct Entry {
-    Entry() : tag(0), name(nullptr) {}
+    Entry() : tag(llvm::dwarf::DW_TAG_null), name(nullptr) {}
     Entry(dw_tag_t t, const char *n) : tag(t), name(n) {}
 
     bool NameMatches(const Entry &rhs) const {
       if (name == rhs.name)
         return true;
       else if (name && rhs.name)
         return strcmp(name, rhs.name) == 0;
       return false;

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

public:
   enum TypeFlags {
     /// Always set for C++, only set for ObjC if this is the
     /// @implementation for class.
     eTypeFlagClassIsImplementation = (1u << 1)
   };
 
   struct DIEInfo {
     dw_offset_t die_offset = DW_INVALID_OFFSET;
-    dw_tag_t tag = 0;
+    dw_tag_t tag = llvm::dwarf::DW_TAG_null;
 
     /// Any flags for this DIEInfo.
     uint32_t type_flags = 0;
 
     /// A 32 bit hash of the fully qualified name.
     uint32_t qualified_name_hash = 0;
 
     DIEInfo() = default;