[Dwarf] DW_TAG_unspecified_type is a type tag.

[JDevlieghere]

Summary

This fixes an incorrect verifier error for a DW_AT_type pointing to DW_TAG_unspecified_type.

error: DIE has DW_AT_type with incompatible tag DW_TAG_unspecified_type

rdar://54059283

[probinson]

This doesn't seem complete. And it's hard to tell, because the list is mostly but not entirely in numeric order.
Mostly it's missing the new v5 type tags (coarray, dynamic, atomic, immutable) which is probably my fault, but some older ones also appear to be missing (restrict, shared).

[aprantl]

FYI. You can derive the complete list by scanning for DW_AT_type in DWARF 5 Appendix A, Table A.1.

[probinson]

In D65914#1621248, @aprantl wrote:

FYI. You can derive the complete list by scanning for DW_AT_type in DWARF 5 Appendix A, Table A.1.

? not really. Any tag that is a type qualifier will have DW_AT_type, but also anything else that simply has a type (DW_TAG_constant, etc).

I do think that the regex DW_TAG_*_type will find all of them.

[aprantl]

In D65914#1621427, @probinson wrote:

In D65914#1621248, @aprantl wrote:

FYI. You can derive the complete list by scanning for DW_AT_type in DWARF 5 Appendix A, Table A.1.

? not really. Any tag that is a type qualifier will have DW_AT_type, but also anything else that simply has a type (DW_TAG_constant, etc).

I do think that the regex DW_TAG_*_type will find all of them.

I'm probably misunderstanding something here, but DW_TAG_constant *is* listed in Appendix A as allowing a DW_AT_type attribute, so are all the DW_TAG_*_type tags.

[probinson]

In D65914#1621471, @aprantl wrote:

In D65914#1621427, @probinson wrote:

In D65914#1621248, @aprantl wrote:

FYI. You can derive the complete list by scanning for DW_AT_type in DWARF 5 Appendix A, Table A.1.

? not really. Any tag that is a type qualifier will have DW_AT_type, but also anything else that simply has a type (DW_TAG_constant, etc).

I do think that the regex DW_TAG_*_type will find all of them.

I'm probably misunderstanding something here, but DW_TAG_constant *is* listed in Appendix A as allowing a DW_AT_type attribute, so are all the DW_TAG_*_type tags.

is-a versus has-a? We want the isType(Tag T) predicate to return true for the tags that DW_AT_type is allowed to *point to* (i.e. whether the tag is-a type), not those tags that permit DW_AT_type as an attribute (i.e., those that have-a type).

[aprantl]

Got it! I misunderstood the purpose of this function.

[JDevlieghere]

Add missing type tags and sort the list alphabetically.

[aprantl]

llvm/include/llvm/BinaryFormat/Dwarf.h

91–92

Looking at the LHS, I think that the list was *meant* to be sorted by encoding value (cf. Table 7.3) which could make it easier to check whether some new group of TAGs have been added. I'm fine either way... Alphabetical also has its advantages.

[aprantl]

llvm/include/llvm/BinaryFormat/Dwarf.h

91–92

The *nicest* way to implement this might be to add a new IS_TYPE field to the TAG macro in Dwarf.def and then generate this switch statement.

[JDevlieghere]

Make type part of the def file.

[aprantl]

Neat. Thanks!

llvm/include/llvm/BinaryFormat/Dwarf.h

 const uint32_t DW_CIE_ID = UINT32_MAX;
 const uint64_t DW64_CIE_ID = UINT64_MAX;
 /// @}
 
 /// Identifier of an invalid DIE offset in the .debug_info section.
 const uint32_t DW_INVALID_OFFSET = UINT32_MAX;
 
 enum Tag : uint16_t {
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) DW_TAG_##NAME = ID,
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) DW_TAG_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_TAG_lo_user = 0x4080,
   DW_TAG_hi_user = 0xffff,
   DW_TAG_user_base = 0x1000 ///< Recommended base for user tags.
 };
 
 inline bool isType(Tag T) {
   switch (T) {
-  case DW_TAG_array_type:
-  case DW_TAG_class_type:
-  case DW_TAG_interface_type:
-  case DW_TAG_enumeration_type:
-  case DW_TAG_pointer_type:
-  case DW_TAG_reference_type:
-  case DW_TAG_rvalue_reference_type:
-  case DW_TAG_string_type:
-  case DW_TAG_structure_type:
-  case DW_TAG_subroutine_type:
-  case DW_TAG_union_type:
-  case DW_TAG_ptr_to_member_type:
-  case DW_TAG_set_type:
-  case DW_TAG_subrange_type:
-  case DW_TAG_base_type:
-  case DW_TAG_const_type:
-  case DW_TAG_file_type:
-  case DW_TAG_packed_type:
-  case DW_TAG_volatile_type:
-  case DW_TAG_typedef:
-    return true;
   default:
     return false;
+#define NONE false
+#define TYPE true
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)                         \
+  case DW_TAG_##NAME:                                                          \
+    return KIND;
+#include "llvm/BinaryFormat/Dwarf.def"
+#undef TYPE
+#undef NONE
   }
 }
 
 /// Attributes.
 enum Attribute : uint16_t {
 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) DW_AT_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_AT_lo_user = 0x2000,

llvm/include/llvm/BinaryFormat/Dwarf.def

#if !(                                                                         \
     (defined HANDLE_DW_CFA && defined HANDLE_DW_CFA_PRED) ||                   \
     defined HANDLE_DW_APPLE_PROPERTY || defined HANDLE_DW_UT ||                \
     defined HANDLE_DWARF_SECTION || defined HANDLE_DW_IDX ||                   \
     defined HANDLE_DW_END)
 #error "Missing macro definition of HANDLE_DW*"
 #endif
 
 #ifndef HANDLE_DW_TAG
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)
 #endif
 
 #ifndef HANDLE_DW_AT
 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_FORM
 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)

 #ifndef HANDLE_DW_IDX
 #define HANDLE_DW_IDX(ID, NAME)
 #endif
 
 #ifndef HANDLE_DW_END
 #define HANDLE_DW_END(ID, NAME)
 #endif
 
-HANDLE_DW_TAG(0x0000, null, 2, DWARF)
-HANDLE_DW_TAG(0x0001, array_type, 2, DWARF)
-HANDLE_DW_TAG(0x0002, class_type, 2, DWARF)
-HANDLE_DW_TAG(0x0003, entry_point, 2, DWARF)
-HANDLE_DW_TAG(0x0004, enumeration_type, 2, DWARF)
-HANDLE_DW_TAG(0x0005, formal_parameter, 2, DWARF)
-HANDLE_DW_TAG(0x0008, imported_declaration, 2, DWARF)
-HANDLE_DW_TAG(0x000a, label, 2, DWARF)
-HANDLE_DW_TAG(0x000b, lexical_block, 2, DWARF)
-HANDLE_DW_TAG(0x000d, member, 2, DWARF)
-HANDLE_DW_TAG(0x000f, pointer_type, 2, DWARF)
-HANDLE_DW_TAG(0x0010, reference_type, 2, DWARF)
-HANDLE_DW_TAG(0x0011, compile_unit, 2, DWARF)
-HANDLE_DW_TAG(0x0012, string_type, 2, DWARF)
-HANDLE_DW_TAG(0x0013, structure_type, 2, DWARF)
-HANDLE_DW_TAG(0x0015, subroutine_type, 2, DWARF)
-HANDLE_DW_TAG(0x0016, typedef, 2, DWARF)
-HANDLE_DW_TAG(0x0017, union_type, 2, DWARF)
-HANDLE_DW_TAG(0x0018, unspecified_parameters, 2, DWARF)
-HANDLE_DW_TAG(0x0019, variant, 2, DWARF)
-HANDLE_DW_TAG(0x001a, common_block, 2, DWARF)
-HANDLE_DW_TAG(0x001b, common_inclusion, 2, DWARF)
-HANDLE_DW_TAG(0x001c, inheritance, 2, DWARF)
-HANDLE_DW_TAG(0x001d, inlined_subroutine, 2, DWARF)
-HANDLE_DW_TAG(0x001e, module, 2, DWARF)
-HANDLE_DW_TAG(0x001f, ptr_to_member_type, 2, DWARF)
-HANDLE_DW_TAG(0x0020, set_type, 2, DWARF)
-HANDLE_DW_TAG(0x0021, subrange_type, 2, DWARF)
-HANDLE_DW_TAG(0x0022, with_stmt, 2, DWARF)
-HANDLE_DW_TAG(0x0023, access_declaration, 2, DWARF)
-HANDLE_DW_TAG(0x0024, base_type, 2, DWARF)
-HANDLE_DW_TAG(0x0025, catch_block, 2, DWARF)
-HANDLE_DW_TAG(0x0026, const_type, 2, DWARF)
-HANDLE_DW_TAG(0x0027, constant, 2, DWARF)
-HANDLE_DW_TAG(0x0028, enumerator, 2, DWARF)
-HANDLE_DW_TAG(0x0029, file_type, 2, DWARF)
-HANDLE_DW_TAG(0x002a, friend, 2, DWARF)
-HANDLE_DW_TAG(0x002b, namelist, 2, DWARF)
-HANDLE_DW_TAG(0x002c, namelist_item, 2, DWARF)
-HANDLE_DW_TAG(0x002d, packed_type, 2, DWARF)
-HANDLE_DW_TAG(0x002e, subprogram, 2, DWARF)
-HANDLE_DW_TAG(0x002f, template_type_parameter, 2, DWARF)
-HANDLE_DW_TAG(0x0030, template_value_parameter, 2, DWARF)
-HANDLE_DW_TAG(0x0031, thrown_type, 2, DWARF)
-HANDLE_DW_TAG(0x0032, try_block, 2, DWARF)
-HANDLE_DW_TAG(0x0033, variant_part, 2, DWARF)
-HANDLE_DW_TAG(0x0034, variable, 2, DWARF)
-HANDLE_DW_TAG(0x0035, volatile_type, 2, DWARF)
+HANDLE_DW_TAG(0x0000, null, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0001, array_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0002, class_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0003, entry_point, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0004, enumeration_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0005, formal_parameter, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0008, imported_declaration, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x000a, label, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x000b, lexical_block, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x000d, member, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x000f, pointer_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0010, reference_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0011, compile_unit, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0012, string_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0013, structure_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0015, subroutine_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0016, typedef, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0017, union_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0018, unspecified_parameters, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0019, variant, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x001a, common_block, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x001b, common_inclusion, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x001c, inheritance, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x001d, inlined_subroutine, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x001e, module, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x001f, ptr_to_member_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0020, set_type, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0021, subrange_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0022, with_stmt, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0023, access_declaration, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0024, base_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0025, catch_block, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0026, const_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0027, constant, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0028, enumerator, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0029, file_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x002a, friend, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x002b, namelist, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x002c, namelist_item, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x002d, packed_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x002e, subprogram, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x002f, template_type_parameter, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0030, template_value_parameter, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0031, thrown_type, 2, DWARF, TYPE)
+HANDLE_DW_TAG(0x0032, try_block, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0033, variant_part, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0034, variable, 2, DWARF, NONE)
+HANDLE_DW_TAG(0x0035, volatile_type, 2, DWARF, TYPE)
 // New in DWARF v3:
-HANDLE_DW_TAG(0x0036, dwarf_procedure, 3, DWARF)
-HANDLE_DW_TAG(0x0037, restrict_type, 3, DWARF)
-HANDLE_DW_TAG(0x0038, interface_type, 3, DWARF)
-HANDLE_DW_TAG(0x0039, namespace, 3, DWARF)
-HANDLE_DW_TAG(0x003a, imported_module, 3, DWARF)
-HANDLE_DW_TAG(0x003b, unspecified_type, 3, DWARF)
-HANDLE_DW_TAG(0x003c, partial_unit, 3, DWARF)
-HANDLE_DW_TAG(0x003d, imported_unit, 3, DWARF)
-HANDLE_DW_TAG(0x003f, condition, 3, DWARF)
-HANDLE_DW_TAG(0x0040, shared_type, 3, DWARF)
+HANDLE_DW_TAG(0x0036, dwarf_procedure, 3, DWARF, NONE)
+HANDLE_DW_TAG(0x0037, restrict_type, 3, DWARF, TYPE)
+HANDLE_DW_TAG(0x0038, interface_type, 3, DWARF, TYPE)
+HANDLE_DW_TAG(0x0039, namespace, 3, DWARF, NONE)
+HANDLE_DW_TAG(0x003a, imported_module, 3, DWARF, NONE)
+HANDLE_DW_TAG(0x003b, unspecified_type, 3, DWARF, TYPE)
+HANDLE_DW_TAG(0x003c, partial_unit, 3, DWARF, NONE)
+HANDLE_DW_TAG(0x003d, imported_unit, 3, DWARF, NONE)
+HANDLE_DW_TAG(0x003f, condition, 3, DWARF, NONE)
+HANDLE_DW_TAG(0x0040, shared_type, 3, DWARF, TYPE)
 // New in DWARF v4:
-HANDLE_DW_TAG(0x0041, type_unit, 4, DWARF)
-HANDLE_DW_TAG(0x0042, rvalue_reference_type, 4, DWARF)
-HANDLE_DW_TAG(0x0043, template_alias, 4, DWARF)
+HANDLE_DW_TAG(0x0041, type_unit, 4, DWARF, NONE)
+HANDLE_DW_TAG(0x0042, rvalue_reference_type, 4, DWARF, TYPE)
+HANDLE_DW_TAG(0x0043, template_alias, 4, DWARF, NONE)
 // New in DWARF v5:
-HANDLE_DW_TAG(0x0044, coarray_type, 5, DWARF)
-HANDLE_DW_TAG(0x0045, generic_subrange, 5, DWARF)
-HANDLE_DW_TAG(0x0046, dynamic_type, 5, DWARF)
-HANDLE_DW_TAG(0x0047, atomic_type, 5, DWARF)
-HANDLE_DW_TAG(0x0048, call_site, 5, DWARF)
-HANDLE_DW_TAG(0x0049, call_site_parameter, 5, DWARF)
-HANDLE_DW_TAG(0x004a, skeleton_unit, 5, DWARF)
-HANDLE_DW_TAG(0x004b, immutable_type, 5, DWARF)
+HANDLE_DW_TAG(0x0044, coarray_type, 5, DWARF, TYPE)
+HANDLE_DW_TAG(0x0045, generic_subrange, 5, DWARF, NONE)
+HANDLE_DW_TAG(0x0046, dynamic_type, 5, DWARF, TYPE)
+HANDLE_DW_TAG(0x0047, atomic_type, 5, DWARF, TYPE)
+HANDLE_DW_TAG(0x0048, call_site, 5, DWARF, NONE)
+HANDLE_DW_TAG(0x0049, call_site_parameter, 5, DWARF, NONE)
+HANDLE_DW_TAG(0x004a, skeleton_unit, 5, DWARF, NONE)
+HANDLE_DW_TAG(0x004b, immutable_type, 5, DWARF, TYPE)
 // Vendor extensions:
-HANDLE_DW_TAG(0x4081, MIPS_loop, 0, MIPS)
-HANDLE_DW_TAG(0x4101, format_label, 0, GNU)
-HANDLE_DW_TAG(0x4102, function_template, 0, GNU)
-HANDLE_DW_TAG(0x4103, class_template, 0, GNU)
-HANDLE_DW_TAG(0x4106, GNU_template_template_param, 0, GNU)
-HANDLE_DW_TAG(0x4107, GNU_template_parameter_pack, 0, GNU)
-HANDLE_DW_TAG(0x4108, GNU_formal_parameter_pack, 0, GNU)
-HANDLE_DW_TAG(0x4109, GNU_call_site, 0, GNU)
-HANDLE_DW_TAG(0x410a, GNU_call_site_parameter, 0, GNU)
-HANDLE_DW_TAG(0x4200, APPLE_property, 0, APPLE)
-HANDLE_DW_TAG(0xb000, BORLAND_property, 0, BORLAND)
-HANDLE_DW_TAG(0xb001, BORLAND_Delphi_string, 0, BORLAND)
-HANDLE_DW_TAG(0xb002, BORLAND_Delphi_dynamic_array, 0, BORLAND)
-HANDLE_DW_TAG(0xb003, BORLAND_Delphi_set, 0, BORLAND)
-HANDLE_DW_TAG(0xb004, BORLAND_Delphi_variant, 0, BORLAND)
+HANDLE_DW_TAG(0x4081, MIPS_loop, 0, MIPS, NONE)
+HANDLE_DW_TAG(0x4101, format_label, 0, GNU, NONE)
+HANDLE_DW_TAG(0x4102, function_template, 0, GNU, NONE)
+HANDLE_DW_TAG(0x4103, class_template, 0, GNU, NONE)
+HANDLE_DW_TAG(0x4106, GNU_template_template_param, 0, GNU, NONE)
+HANDLE_DW_TAG(0x4107, GNU_template_parameter_pack, 0, GNU, NONE)
+HANDLE_DW_TAG(0x4108, GNU_formal_parameter_pack, 0, GNU, NONE)
+HANDLE_DW_TAG(0x4109, GNU_call_site, 0, GNU, NONE)
+HANDLE_DW_TAG(0x410a, GNU_call_site_parameter, 0, GNU, NONE)
+HANDLE_DW_TAG(0x4200, APPLE_property, 0, APPLE, NONE)
+HANDLE_DW_TAG(0xb000, BORLAND_property, 0, BORLAND, NONE)
+HANDLE_DW_TAG(0xb001, BORLAND_Delphi_string, 0, BORLAND, NONE)
+HANDLE_DW_TAG(0xb002, BORLAND_Delphi_dynamic_array, 0, BORLAND, NONE)
+HANDLE_DW_TAG(0xb003, BORLAND_Delphi_set, 0, BORLAND, NONE)
+HANDLE_DW_TAG(0xb004, BORLAND_Delphi_variant, 0, BORLAND, NONE)
 
 // Attributes.
 HANDLE_DW_AT(0x01, sibling, 2, DWARF)
 HANDLE_DW_AT(0x02, location, 2, DWARF)
 HANDLE_DW_AT(0x03, name, 2, DWARF)
 HANDLE_DW_AT(0x09, ordering, 2, DWARF)
 HANDLE_DW_AT(0x0b, byte_size, 2, DWARF)
 HANDLE_DW_AT(0x0c, bit_offset, 2, DWARF)

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 template <> struct MappingTraits<DWARFYAML::LineTable> {
   static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
 };
 
 template <> struct MappingTraits<DWARFYAML::InitialLength> {
   static void mapping(IO &IO, DWARFYAML::InitialLength &DWARF);
 };
 
-#define HANDLE_DW_TAG(unused, name, unused2, unused3)                          \
+#define HANDLE_DW_TAG(unused, name, unused2, unused3, unused4)                 \
   io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name);
 
 template <> struct ScalarEnumerationTraits<dwarf::Tag> {
   static void enumeration(IO &io, dwarf::Tag &value) {
 #include "llvm/BinaryFormat/Dwarf.def"
     io.enumFallback<Hex16>(value);
   }
 };

llvm/lib/BinaryFormat/Dwarf.cpp

 
 using namespace llvm;
 using namespace dwarf;
 
 StringRef llvm::dwarf::TagString(unsigned Tag) {
   switch (Tag) {
   default:
     return StringRef();
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)                         \
   case DW_TAG_##NAME:                                                          \
     return "DW_TAG_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
 unsigned llvm::dwarf::getTag(StringRef TagString) {
   return StringSwitch<unsigned>(TagString)
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)                         \
   .Case("DW_TAG_" #NAME, DW_TAG_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Default(DW_TAG_invalid);
 }
 
 unsigned llvm::dwarf::TagVersion(dwarf::Tag Tag) {
   switch (Tag) {
   default:
     return 0;
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)                         \
   case DW_TAG_##NAME:                                                          \
     return VERSION;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
 unsigned llvm::dwarf::TagVendor(dwarf::Tag Tag) {
   switch (Tag) {
   default:
     return 0;
-#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
+#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND)                         \
   case DW_TAG_##NAME:                                                          \
     return DWARF_VENDOR_##VENDOR;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
 StringRef llvm::dwarf::ChildrenString(unsigned Children) {
   switch (Children) {

llvm/test/DebugInfo/X86/template.ll

 ; REQUIRES: object-emission
 
 ; RUN: llc -mtriple=x86_64-linux -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
+; RUN: llc -mtriple=x86_64-linux -O0 -filetype=obj < %s | not llvm-dwarfdump -verify - | FileCheck %s --check-prefix VERIFY
 
 ; IR generated with `clang++ -g -emit-llvm -S` from the following code:
 ; template<int x, int*, template<typename> class y, decltype(nullptr) n, int ...z>  int func() {
 ;  var<int> = 5;
 ;  return var<int>;
 ; }
 ; template<typename> struct y_impl { struct nested { }; };
 ; int glbl = func<3, &glbl, y_impl, nullptr, 1, 2>();
 ; y_impl<int>::nested n;
 
+; VERIFY-NOT: error: DIE has DW_AT_type with incompatible tag DW_TAG_unspecified_type
+; VERIFY: error: DIEs have overlapping address ranges
+
 ; CHECK: [[INT:0x[0-9a-f]*]]:{{ *}}DW_TAG_base_type
 ; CHECK-NEXT: DW_AT_name{{.*}} = "int"
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK: DW_AT_name{{.*}}"y_impl<int>"
 ; CHECK-NOT: {{TAG|NULL}}
 ; CHECK: DW_TAG_template_type_parameter