[Debug-Info] make createAndAddDIE have dwarf::Tag type parameter - NFC

[shchenz]

Summary

This is a suggestion from @dblaikie in the code review of D100630.

Change the Tag parameter type to dwarf::Tag for function createAndAddDIE

[dblaikie]

Looks good, thanks!

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

279–280

You can remove this now.

2047

You can remove this now

llvm/include/llvm/IR/DebugInfoMetadata.h

if (S.empty())
       return nullptr;
     return MDString::get(Context, S);
   }
 
   /// Allow subclasses to mutate the tag.
   void setTag(unsigned Tag) { SubclassData16 = Tag; }
 
 public:
-  unsigned getTag() const { return SubclassData16; }
+  dwarf::Tag getTag() const { return (dwarf::Tag)SubclassData16; }
 
   /// Debug info flags.
   ///
   /// The three accessibility flags are mutually exclusive and rolled together
   /// in the first two bits.
   enum DIFlags : uint32_t {
 #define HANDLE_DI_FLAG(ID, NAME) Flag##NAME = ID,
 #define DI_FLAG_LARGEST_NEEDED
DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, StringRef Header,
                     (Tag, Header, DwarfOps))
   DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header,
                                     ArrayRef<Metadata *> DwarfOps),
                     (Tag, Header, DwarfOps))
 
   /// Return a (temporary) clone of this.
   TempGenericDINode clone() const { return cloneImpl(); }
 
-  unsigned getTag() const { return SubclassData16; }
+  dwarf::Tag getTag() const { return (dwarf::Tag)SubclassData16; }
   StringRef getHeader() const { return getStringOperand(0); }
   MDString *getRawHeader() const { return getOperandAs<MDString>(0); }
 
   op_iterator dwarf_op_begin() const { return op_begin() + 1; }
   op_iterator dwarf_op_end() const { return op_end(); }
   op_range dwarf_operands() const {
     return op_range(dwarf_op_begin(), dwarf_op_end());
   }

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

static StringRef getPrettyScopeName(const DIScope *Scope) {
   switch (Scope->getTag()) {
   case dwarf::DW_TAG_enumeration_type:
   case dwarf::DW_TAG_class_type:
   case dwarf::DW_TAG_structure_type:
   case dwarf::DW_TAG_union_type:
     return "<unnamed-tag>";
   case dwarf::DW_TAG_namespace:
     return "`anonymous namespace'";
+  default:
+    return StringRef();
   }
 
   return StringRef();
 }
 
 const DISubprogram *CodeViewDebug::collectParentScopeNames(
     const DIScope *Scope, SmallVectorImpl<StringRef> &QualifiedNameComponents) {
   const DISubprogram *ClosestSubprogram = nullptr;
   while (Scope != nullptr) {
     if (ClosestSubprogram == nullptr)
       ClosestSubprogram = dyn_cast<DISubprogram>(Scope);
static bool shouldEmitUdt(const DIType *T) {
   // MSVC does not emit UDTs for typedefs that are scoped to classes.
   if (T->getTag() == dwarf::DW_TAG_typedef) {
     if (DIScope *Scope = T->getScope()) {
       switch (Scope->getTag()) {
       case dwarf::DW_TAG_structure_type:
       case dwarf::DW_TAG_class_type:
       case dwarf::DW_TAG_union_type:
         return false;
+      default:
+          // do nothing.
+          ;
       }
     }
   }
 
   while (true) {
     if (!T || T->isForwardDecl())
       return false;
 
default:
     llvm_unreachable("unhandled virtuality case");
   }
 
   return MethodKind::Vanilla;
 }
 
 static TypeRecordKind getRecordKind(const DICompositeType *Ty) {
   switch (Ty->getTag()) {
-  case dwarf::DW_TAG_class_type:     return TypeRecordKind::Class;
-  case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct;
+  case dwarf::DW_TAG_class_type:
+    return TypeRecordKind::Class;
+  case dwarf::DW_TAG_structure_type:
+    return TypeRecordKind::Struct;
+  default:
+    llvm_unreachable("unexpected tag");
   }
   llvm_unreachable("unexpected tag");
 }
 
 /// Return ClassOptions that should be present on both the forward declaration
 /// and the defintion of a tag type.
 static ClassOptions getCommonClassOptions(const DICompositeType *Ty) {
   ClassOptions CO = ClassOptions::None;
 
   // MSVC always sets this flag, even for local types. Clang doesn't always

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
   /// Construct DIEs for types that contain vtables.
   void constructContainingTypeDIEs();
 
   /// Construct function argument DIEs.
   void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args);
 
   /// Create a DIE with the given Tag, add the DIE to its parent, and
   /// call insertDIE if MD is not null.
-  DIE &createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N = nullptr);
+  DIE &createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N = nullptr);
 
   bool useSegmentedStringOffsetsTable() const {
     return DD->useSegmentedStringOffsetsTable();
   }
 
   /// Compute the size of a header for this unit, not including the initial
   /// length field.
   virtual unsigned getHeaderSize() const {

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (!CU)
     CU = getUnitDie().getUnit();
   if (!EntryCU)
     EntryCU = getUnitDie().getUnit();
   addAttribute(Die, Attribute,
                EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
                Entry);
 }
 
-DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
-  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
+DIE &DwarfUnit::createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N) {
+  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, Tag));
   if (N)
     insertDIE(N, &Die);
   return Die;
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
   Loc->ComputeSize(Asm);
   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.