Change DWARF parser to use enumerations for DWARF tags, attributes and forms.

[clayborg]

Summary

To improve our ability to debug DWARF code I propose that we switch all variables for tags, attributes and forms over to use the llvm::dwarf enumerations instead of using uint16_t values. This allows easier debugging as users can see the values of the enumerations in the variables view that will show the enumeration string instead of just a number.

[aprantl]

lib/DebugInfo/DWARF/DWARFFormValue.cpp

126

Here's an idea: How about adding a

template<typename EnumType>
llvm::Optional<EnumType>
getULEB128AsEnum() {
  // Decode ULEB.
  uint64_t Val = ...; // what about larger values?
  if (Val >= EnumType::getMinValue() && Val <= EnumType::getMaxValue())
    return static_cast<EnumType>(Val);
  return None;
}

?

This way we could guarantee that on of the enums if it is passed as an enum is always well-formed. Then we would never need a default case in a switch over a dwarf enum and could benefit from the not-all-enum-cases-covered-by-switch warning.

Is that feasible?

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

46–47

Skip the else after return ( http://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return )

lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

42–45

What happened to these error paths?

44–52

Drop the const from local values - we don't generally do that (& can be confused with "const T&" - might be read as though a reference was intended & accidentally omitted)

Also, if you like, you can use "auto" for the type when the RHS has the type prominently in the static_cast type parameter anyway.

(as you did later with AtomForm)

lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

211

Drop the const

237

I'd probably drop the const here, even though it was there in the original.

(similarly in a few cases below)

lib/DebugInfo/DWARF/DWARFFormValue.cpp

126–127

What's this added/here for?

275–276

Perhaps it'd work to have enums defined for the beginning of the user-defined extension space - and just never add support for those to these switches, then they wouldn't be fully covered switches and the warning wouldn't fire on the default?

[clayborg]

I will make the changes dblaikie suggested.

lib/DebugInfo/DWARF/DWARFFormValue.cpp

125–128

This was added because the switch statement was on a uint16_t before and now it is on a dwarf::Form enumeration. It will warn that not all cases were handled. The cases don't include all cases because most case are handled above the current switch statement. So this was added to avoid a "not all enum cases were handled.

275–276

That is a good idea. I will do that.

[clayborg]

Added clarification on the "where did this go" in inlined comments.

lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

41–45

They are combined into the "else" clause on line 51 on the right. No need to check that nothing was parsed by comparing the offset. If there is no data, zero will be returned. So the changes on the right check the success case first:

if (A && F)

then check if both are zero, which is the success case in the middle:

} else if (A == 0 && F == 0) {

And then check of either A or F was zero which is the error case.

[clayborg]

Fixed all requests.

[clayborg]

Updated diffs with all requested changes

[dblaikie]

lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

49

Maybe "Finished" rather than "Successfully" (or "Successfully finished") - or perhaps "Reached the end-of-abbreviation marker" or something.

52

Maybe there's a better way to phrase this comment (I get what you're trying to say, but it parses a bit oddly for my brain at least - "both which is an error" almost sounds like it's referring to the previous case, which isn't an error but the end-of-input marker).

[aprantl]

lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

52

FYI, the LLVM coding standard prefers full sentences in comments with a trailing '.' (http://llvm.org/docs/CodingStandards.html#commenting).

[clayborg]

Improved comments in the abbreviation declaration.

[clayborg]

Fixed comments and marked them as done.

[clayborg]

SVN revision 285309.

include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

 //===-- DWARFAbbreviationDeclaration.h --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFABBREVIATIONDECLARATION_H
 #define LLVM_LIB_DEBUGINFO_DWARFABBREVIATIONDECLARATION_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Dwarf.h"
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFAbbreviationDeclaration {
 public:
   struct AttributeSpec {
-    AttributeSpec(uint16_t Attr, uint16_t Form) : Attr(Attr), Form(Form) {}
-    uint16_t Attr;
-    uint16_t Form;
+    AttributeSpec(dwarf::Attribute A, dwarf::Form F) : Attr(A), Form(F) {}
+    dwarf::Attribute Attr;
+    dwarf::Form Form;
   };
   typedef SmallVector<AttributeSpec, 8> AttributeSpecVector;
 
   DWARFAbbreviationDeclaration();
 
   uint32_t getCode() const { return Code; }
-  uint32_t getTag() const { return Tag; }
+  dwarf::Tag getTag() const { return Tag; }
   bool hasChildren() const { return HasChildren; }
 
   typedef iterator_range<AttributeSpecVector::const_iterator>
   attr_iterator_range;
 
   attr_iterator_range attributes() const {
     return attr_iterator_range(AttributeSpecs.begin(), AttributeSpecs.end());
   }
 
-  uint16_t getFormByIndex(uint32_t idx) const {
-    return idx < AttributeSpecs.size() ? AttributeSpecs[idx].Form : 0;
+  dwarf::Form getFormByIndex(uint32_t idx) const {
+    if (idx < AttributeSpecs.size())
+      return AttributeSpecs[idx].Form;
+    return dwarf::Form(0);
   }
 
-  uint32_t findAttributeIndex(uint16_t attr) const;
+  uint32_t findAttributeIndex(dwarf::Attribute attr) const;
   bool extract(DataExtractor Data, uint32_t* OffsetPtr);
   void dump(raw_ostream &OS) const;
 
 private:
   void clear();
 
   uint32_t Code;
-  uint32_t Tag;
+  dwarf::Tag Tag;
   bool HasChildren;
 
   AttributeSpecVector AttributeSpecs;
 };
 
 }
 
 #endif

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

 //===--- DWARFAcceleratorTable.h --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFACCELERATORTABLE_H
 #define LLVM_LIB_DEBUGINFO_DWARFACCELERATORTABLE_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
+#include "llvm/Support/Dwarf.h"
 #include <cstdint>
 
 namespace llvm {
 
 class DWARFAcceleratorTable {
 
   struct Header {
     uint32_t Magic;
     uint16_t Version;
     uint16_t HashFunction;
     uint32_t NumBuckets;
     uint32_t NumHashes;
     uint32_t HeaderDataLength;
   };
 
   struct HeaderData {
     typedef uint16_t AtomType;
-    typedef uint16_t Form;
+    typedef dwarf::Form Form;
     uint32_t DIEOffsetBase;
     SmallVector<std::pair<AtomType, Form>, 3> Atoms;
   };
 
   struct Header Hdr;
   struct HeaderData HdrData;
   DataExtractor AccelSection;
   DataExtractor StringSection;

include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h

class DWARFDebugInfoEntryMinimal {
   const DWARFAbbreviationDeclaration *AbbrevDecl;
 public:
   DWARFDebugInfoEntryMinimal()
     : Offset(0), SiblingIdx(0), AbbrevDecl(nullptr) {}
 
   void dump(raw_ostream &OS, DWARFUnit *u, unsigned recurseDepth,
             unsigned indent = 0) const;
   void dumpAttribute(raw_ostream &OS, DWARFUnit *u, uint32_t *offset_ptr,
-                     uint16_t attr, uint16_t form, unsigned indent = 0) const;
+                     dwarf::Attribute attr, dwarf::Form form, 
+                     unsigned indent = 0) const;
 
   /// Extracts a debug info entry, which is a child of a given unit,
   /// starting at a given offset. If DIE can't be extracted, returns false and
   /// doesn't change OffsetPtr.
   bool extractFast(const DWARFUnit *U, uint32_t *OffsetPtr);
 
   uint32_t getTag() const { return AbbrevDecl ? AbbrevDecl->getTag() : 0; }
   bool isNULL() const { return AbbrevDecl == nullptr; }
void setSibling(const DWARFDebugInfoEntryMinimal *Sibling) {
     } else
       SiblingIdx = 0;
   }
 
   const DWARFAbbreviationDeclaration *getAbbreviationDeclarationPtr() const {
     return AbbrevDecl;
   }
 
-  bool getAttributeValue(const DWARFUnit *U, const uint16_t Attr,
+  bool getAttributeValue(const DWARFUnit *U, dwarf::Attribute Attr,
                          DWARFFormValue &FormValue) const;
 
-  const char *getAttributeValueAsString(const DWARFUnit *U, const uint16_t Attr,
+  const char *getAttributeValueAsString(const DWARFUnit *U, 
+                                        dwarf::Attribute Attr,
                                         const char *FailValue) const;
 
-  uint64_t getAttributeValueAsAddress(const DWARFUnit *U, const uint16_t Attr,
+  uint64_t getAttributeValueAsAddress(const DWARFUnit *U, 
+                                      dwarf::Attribute Attr,
                                       uint64_t FailValue) const;
 
   uint64_t getAttributeValueAsUnsignedConstant(const DWARFUnit *U,
-                                               const uint16_t Attr,
+                                               dwarf::Attribute Attr,
                                                uint64_t FailValue) const;
 
-  uint64_t getAttributeValueAsReference(const DWARFUnit *U, const uint16_t Attr,
+  uint64_t getAttributeValueAsReference(const DWARFUnit *U, 
+                                        dwarf::Attribute Attr,
                                         uint64_t FailValue) const;
 
   uint64_t getAttributeValueAsSectionOffset(const DWARFUnit *U,
-                                            const uint16_t Attr,
+                                            dwarf::Attribute Attr,
                                             uint64_t FailValue) const;
 
   uint64_t getRangesBaseAttribute(const DWARFUnit *U, uint64_t FailValue) const;
 
   /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
   /// Returns true if both attributes are present.
   bool getLowAndHighPC(const DWARFUnit *U, uint64_t &LowPC,
                        uint64_t &HighPC) const;

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

 //===-- DWARFFormValue.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFFORMVALUE_H
 #define LLVM_DEBUGINFO_DWARFFORMVALUE_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Dwarf.h"
 
 namespace llvm {
 
 template <typename T> class ArrayRef;
 class DWARFUnit;
 class raw_ostream;
 
 class DWARFFormValue {
struct ValueType {
     union {
       uint64_t uval;
       int64_t sval;
       const char* cstr;
     };
     const uint8_t* data;
   };
 
-  uint16_t Form;   // Form for this value.
+  dwarf::Form Form;   // Form for this value.
   ValueType Value; // Contains all data for the form.
 
 public:
-  DWARFFormValue(uint16_t Form = 0) : Form(Form) {}
-  uint16_t getForm() const { return Form; }
+  DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F) {}
+  dwarf::Form getForm() const { return Form; }
   bool isFormClass(FormClass FC) const;
 
   void dump(raw_ostream &OS, const DWARFUnit *U) const;
 
   /// \brief extracts a value in data at offset *offset_ptr.
   ///
   /// The passed DWARFUnit is allowed to be nullptr, in which
   /// case no relocation processing will be performed and some
public:
   Optional<int64_t> getAsSignedConstant() const;
   Optional<const char *> getAsCString(const DWARFUnit *U) const;
   Optional<uint64_t> getAsAddress(const DWARFUnit *U) const;
   Optional<uint64_t> getAsSectionOffset() const;
   Optional<ArrayRef<uint8_t>> getAsBlock() const;
 
   bool skipValue(DataExtractor debug_info_data, uint32_t *offset_ptr,
                  const DWARFUnit *u) const;
-  static bool skipValue(uint16_t form, DataExtractor debug_info_data,
+  static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
                         uint32_t *offset_ptr, const DWARFUnit *u);
-  static bool skipValue(uint16_t form, DataExtractor debug_info_data,
+  static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
                         uint32_t *offset_ptr, uint16_t Version,
                         uint8_t AddrSize);
 
   static ArrayRef<uint8_t> getFixedFormSizes(uint8_t AddrSize,
                                              uint16_t Version);
 private:
   void dumpString(raw_ostream &OS, const DWARFUnit *U) const;
 };
 
 }
 
 #endif

include/llvm/Support/Dwarf.h

enum Form : uint16_t {
   DW_FORM_ref4 = 0x13,
   DW_FORM_ref8 = 0x14,
   DW_FORM_ref_udata = 0x15,
   DW_FORM_indirect = 0x16,
   DW_FORM_sec_offset = 0x17,
   DW_FORM_exprloc = 0x18,
   DW_FORM_flag_present = 0x19,
   DW_FORM_ref_sig8 = 0x20,
   
+  DW_FORM_lo_user = 0x1f00,
   // Extensions for Fission proposal
   DW_FORM_GNU_addr_index = 0x1f01,
   DW_FORM_GNU_str_index = 0x1f02,
 
   // Alternate debug sections proposal (output of "dwz" tool).
   DW_FORM_GNU_ref_alt = 0x1f20,
   DW_FORM_GNU_strp_alt = 0x1f21
 };

include/llvm/Support/Dwarf.def

 #ifndef HANDLE_DW_VIRTUALITY
 #define HANDLE_DW_VIRTUALITY(ID, NAME)
 #endif
 
 #ifndef HANDLE_DW_CC
 #define HANDLE_DW_CC(ID, NAME)
 #endif
 
-
+HANDLE_DW_TAG(0x0000, null)
 HANDLE_DW_TAG(0x0001, array_type)
 HANDLE_DW_TAG(0x0002, class_type)
 HANDLE_DW_TAG(0x0003, entry_point)
 HANDLE_DW_TAG(0x0004, enumeration_type)
 HANDLE_DW_TAG(0x0005, formal_parameter)
 HANDLE_DW_TAG(0x0008, imported_declaration)
 HANDLE_DW_TAG(0x000a, label)
 HANDLE_DW_TAG(0x000b, lexical_block)

lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace dwarf;
 
 void DWARFAbbreviationDeclaration::clear() {
   Code = 0;
-  Tag = 0;
+  Tag = DW_TAG_null;
   HasChildren = false;
   AttributeSpecs.clear();
 }
 
 DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration() {
   clear();
 }
 
 bool
 DWARFAbbreviationDeclaration::extract(DataExtractor Data, uint32_t* OffsetPtr) {
   clear();
   Code = Data.getULEB128(OffsetPtr);
   if (Code == 0) {
     return false;
   }
-  Tag = Data.getULEB128(OffsetPtr);
+  Tag = static_cast<llvm::dwarf::Tag>(Data.getULEB128(OffsetPtr));
+  if (Tag == DW_TAG_null) {
+    clear();
+    return false;
+  }
   uint8_t ChildrenByte = Data.getU8(OffsetPtr);
   HasChildren = (ChildrenByte == DW_CHILDREN_yes);
 
   while (true) {
-    uint32_t CurOffset = *OffsetPtr;
-    uint16_t Attr = Data.getULEB128(OffsetPtr);
-    if (CurOffset == *OffsetPtr) {
-      clear();
-      return false;
-    }
-    CurOffset = *OffsetPtr;
-    uint16_t Form = Data.getULEB128(OffsetPtr);
-    if (CurOffset == *OffsetPtr) {
-      clear();
-      return false;
-    }
-    if (Attr == 0 && Form == 0)
+    auto A = static_cast<Attribute>(Data.getULEB128(OffsetPtr));
+    auto F = static_cast<Form>(Data.getULEB128(OffsetPtr));
+    if (A && F) {
+        AttributeSpecs.push_back(AttributeSpec(A, F));
+    } else if (A == 0 && F == 0) {
+      // Successfully parsed this abbreviation
       break;
-    AttributeSpecs.push_back(AttributeSpec(Attr, Form));
-  }
-
-  if (Tag == 0) {
+    } else {
+      // Either the attribute or form was zero, but not both which is an error
       clear();
       return false;
     }
+  }
   return true;
 }
 
 void DWARFAbbreviationDeclaration::dump(raw_ostream &OS) const {
   auto tagString = TagString(getTag());
   OS << '[' << getCode() << "] ";
   if (!tagString.empty())
     OS << tagString;
for (const AttributeSpec &Spec : AttributeSpecs) {
     else
       OS << format("DW_FORM_Unknown_%x", Spec.Form);
     OS << '\n';
   }
   OS << '\n';
 }
 
 uint32_t
-DWARFAbbreviationDeclaration::findAttributeIndex(uint16_t attr) const {
+DWARFAbbreviationDeclaration::findAttributeIndex(dwarf::Attribute attr) const {
   for (uint32_t i = 0, e = AttributeSpecs.size(); i != e; ++i) {
     if (AttributeSpecs[i].Attr == attr)
       return i;
   }
   return -1U;
 }

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

if (!AccelSection.isValidOffset(sizeof(Hdr) + Hdr.HeaderDataLength +
                                   Hdr.NumBuckets*4 + Hdr.NumHashes*8))
     return false;
 
   HdrData.DIEOffsetBase = AccelSection.getU32(&Offset);
   uint32_t NumAtoms = AccelSection.getU32(&Offset);
 
   for (unsigned i = 0; i < NumAtoms; ++i) {
     uint16_t AtomType = AccelSection.getU16(&Offset);
-    uint16_t AtomForm = AccelSection.getU16(&Offset);
+    auto AtomForm = static_cast<dwarf::Form>(AccelSection.getU16(&Offset));
     HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm));
   }
 
   return true;
 }
 
 void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
   // Dump the header.

lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
                  AddressSize*2, Range.first,
                  AddressSize*2, Range.second);
   }
 }
 
 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
                                                DWARFUnit *u,
                                                uint32_t *offset_ptr,
-                                               uint16_t attr, uint16_t form,
+                                               dwarf::Attribute attr, 
+                                               dwarf::Form form,
                                                unsigned indent) const {
   const char BaseIndent[] = "            ";
   OS << BaseIndent;
   OS.indent(indent+2);
   auto attrString = AttributeString(attr);
   if (!attrString.empty())
     WithColor(OS, syntax::Attribute) << attrString;
   else
if (nullptr == AbbrevDecl) {
     return false;
   }
   ArrayRef<uint8_t> FixedFormSizes = DWARFFormValue::getFixedFormSizes(
       U->getAddressByteSize(), U->getVersion());
   assert(FixedFormSizes.size() > 0);
 
   // Skip all data in the .debug_info for the attributes
   for (const auto &AttrSpec : AbbrevDecl->attributes()) {
-    uint16_t Form = AttrSpec.Form;
+    auto Form = AttrSpec.Form;
 
     uint8_t FixedFormSize =
         (Form < FixedFormSizes.size()) ? FixedFormSizes[Form] : 0;
     if (FixedFormSize)
       *OffsetPtr += FixedFormSize;
     else if (!DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U)) {
       // Restore the original offset.
       *OffsetPtr = Offset;
       return false;
     }
   }
   return true;
 }
 
 bool DWARFDebugInfoEntryMinimal::isSubprogramDIE() const {
   return getTag() == DW_TAG_subprogram;
 }
 
 bool DWARFDebugInfoEntryMinimal::isSubroutineDIE() const {
   uint32_t Tag = getTag();
   return Tag == DW_TAG_subprogram ||
          Tag == DW_TAG_inlined_subroutine;
 }
 
-bool DWARFDebugInfoEntryMinimal::getAttributeValue(
-    const DWARFUnit *U, const uint16_t Attr, DWARFFormValue &FormValue) const {
+bool DWARFDebugInfoEntryMinimal::getAttributeValue(const DWARFUnit *U, 
+    dwarf::Attribute Attr, DWARFFormValue &FormValue) const {
   if (!AbbrevDecl)
     return false;
 
   uint32_t AttrIdx = AbbrevDecl->findAttributeIndex(Attr);
   if (AttrIdx == -1U)
     return false;
 
   DataExtractor DebugInfoData = U->getDebugInfoExtractor();
   uint32_t DebugInfoOffset = getOffset();
 
   // Skip the abbreviation code so we are at the data for the attributes
   DebugInfoData.getULEB128(&DebugInfoOffset);
 
   // Skip preceding attribute values.
   for (uint32_t i = 0; i < AttrIdx; ++i) {
     DWARFFormValue::skipValue(AbbrevDecl->getFormByIndex(i),
                               DebugInfoData, &DebugInfoOffset, U);
   }
 
   FormValue = DWARFFormValue(AbbrevDecl->getFormByIndex(AttrIdx));
   return FormValue.extractValue(DebugInfoData, &DebugInfoOffset, U);
 }
 
 const char *DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
-    const DWARFUnit *U, const uint16_t Attr, const char *FailValue) const {
+    const DWARFUnit *U, dwarf::Attribute Attr, 
+    const char *FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<const char *> Result = FormValue.getAsCString(U);
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress(
-    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
+    const DWARFUnit *U, dwarf::Attribute Attr, 
+    uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<uint64_t> Result = FormValue.getAsAddress(U);
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsignedConstant(
-    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
+    const DWARFUnit *U, dwarf::Attribute Attr, 
+    uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<uint64_t> Result = FormValue.getAsUnsignedConstant();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsReference(
-    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
+    const DWARFUnit *U, dwarf::Attribute Attr, 
+    uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<uint64_t> Result = FormValue.getAsReference(U);
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsSectionOffset(
-    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
+    const DWARFUnit *U, dwarf::Attribute Attr, 
+    uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<uint64_t> Result = FormValue.getAsSectionOffset();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t

lib/DebugInfo/DWARF/DWARFFormValue.cpp

bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   switch (Form) {
   case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return (FC == FC_Reference);
   case DW_FORM_GNU_addr_index:
     return (FC == FC_Address);
   case DW_FORM_GNU_str_index:
   case DW_FORM_GNU_strp_alt:
     return (FC == FC_String);
+  default:
+    break;
   }
   // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
   // Don't check for DWARF version here, as some producers may still do this
   // by mistake.
   return (Form == DW_FORM_data4 || Form == DW_FORM_data8) &&
          FC == FC_SectionOffset;
 }
 
 bool DWARFFormValue::extractValue(DataExtractor data, uint32_t *offset_ptr,
do {
     case DW_FORM_udata:
     case DW_FORM_ref_udata:
       Value.uval = data.getULEB128(offset_ptr);
       break;
     case DW_FORM_string:
       Value.cstr = data.getCStr(offset_ptr);
       break;
     case DW_FORM_indirect:
-      Form = data.getULEB128(offset_ptr);
+      Form = static_cast<dwarf::Form>(data.getULEB128(offset_ptr));
       indirect = true;
       break;
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_GNU_strp_alt: {
       // FIXME: This is 64-bit for DWARF64.
       Value.uval = data.getU32(offset_ptr);

 
 bool
 DWARFFormValue::skipValue(DataExtractor debug_info_data, uint32_t* offset_ptr,
                           const DWARFUnit *cu) const {
   return DWARFFormValue::skipValue(Form, debug_info_data, offset_ptr, cu);
 }
 
 bool
-DWARFFormValue::skipValue(uint16_t form, DataExtractor debug_info_data,
+DWARFFormValue::skipValue(dwarf::Form form, DataExtractor debug_info_data,
                           uint32_t *offset_ptr, const DWARFUnit *cu) {
   return skipValue(form, debug_info_data, offset_ptr, cu->getVersion(),
                    cu->getAddressByteSize());
 }
-bool DWARFFormValue::skipValue(uint16_t form, DataExtractor debug_info_data,
-                               uint32_t *offset_ptr, uint16_t Version,
-                               uint8_t AddrSize) {
+bool 
+DWARFFormValue::skipValue(dwarf::Form form, DataExtractor debug_info_data,
   bool indirect = false;
   do {
     switch (form) {
     // Blocks if inlined data that have a length field and the data bytes
     // inlined in the .debug_info
     case DW_FORM_exprloc:
     case DW_FORM_block: {
       uint64_t size = debug_info_data.getULEB128(offset_ptr);
       *offset_ptr += size;
       return true;
     }
     case DW_FORM_block1: {
do {
     case DW_FORM_ref_udata:
     case DW_FORM_GNU_str_index:
     case DW_FORM_GNU_addr_index:
       debug_info_data.getULEB128(offset_ptr);
       return true;
 
     case DW_FORM_indirect:
       indirect = true;
-      form = debug_info_data.getULEB128(offset_ptr);
+      form = static_cast<dwarf::Form>(debug_info_data.getULEB128(offset_ptr));
       break;
 
     // FIXME: 4 for DWARF32, 8 for DWARF64.
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_GNU_strp_alt:
       *offset_ptr += 4;

tools/llvm-dwp/llvm-dwp.cpp

 
 struct CompileUnitIdentifiers {
   uint64_t Signature = 0;
   const char *Name = "";
   const char *DWOName = "";
 };
 
 static Expected<const char *>
-getIndexedString(uint32_t Form, DataExtractor InfoData, uint32_t &InfoOffset,
-                 StringRef StrOffsets, StringRef Str) {
+getIndexedString(dwarf::Form Form, DataExtractor InfoData, 
+                 uint32_t &InfoOffset, StringRef StrOffsets, StringRef Str) {
   if (Form == dwarf::DW_FORM_string)
     return InfoData.getCStr(&InfoOffset);
   if (Form != dwarf::DW_FORM_GNU_str_index)
     return make_error<DWPError>(
         "string field encoded without DW_FORM_string or DW_FORM_GNU_str_index");
   auto StrIndex = InfoData.getULEB128(&InfoOffset);
   DataExtractor StrOffsetsData(StrOffsets, true, 0);
   uint32_t StrOffsetsOffset = 4 * StrIndex;
static Expected<CompileUnitIdentifiers> getCUIdentifiers(StringRef Abbrev,
   uint16_t Version = InfoData.getU16(&Offset);
   InfoData.getU32(&Offset); // Abbrev offset (should be zero)
   uint8_t AddrSize = InfoData.getU8(&Offset);
 
   uint32_t AbbrCode = InfoData.getULEB128(&Offset);
 
   DataExtractor AbbrevData(Abbrev, true, 0);
   uint32_t AbbrevOffset = getCUAbbrev(Abbrev, AbbrCode);
-  uint64_t Tag = AbbrevData.getULEB128(&AbbrevOffset);
+  auto Tag = static_cast<dwarf::Tag>(AbbrevData.getULEB128(&AbbrevOffset));
   if (Tag != dwarf::DW_TAG_compile_unit)
     return make_error<DWPError>("top level DIE is not a compile unit");
   // DW_CHILDREN
   AbbrevData.getU8(&AbbrevOffset);
   uint32_t Name;
-  uint32_t Form;
+  dwarf::Form Form;
   CompileUnitIdentifiers ID;
   while ((Name = AbbrevData.getULEB128(&AbbrevOffset)) |
-             (Form = AbbrevData.getULEB128(&AbbrevOffset)) &&
+         (Form = static_cast<dwarf::Form>(AbbrevData.getULEB128(&AbbrevOffset))) &&
          (Name != 0 || Form != 0)) {
     switch (Name) {
     case dwarf::DW_AT_name: {
       Expected<const char *> EName =
           getIndexedString(Form, InfoData, Offset, StrOffsets, Str);
       if (!EName)
         return EName.takeError();
       ID.Name = *EName;

unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp

TEST(DWARFFormValue, FixedFormSizes) {
   sizes = DWARFFormValue::getFixedFormSizes(8, 2);
   EXPECT_EQ(sizes[DW_FORM_addr], sizes[DW_FORM_ref_addr]);
   sizes = DWARFFormValue::getFixedFormSizes(8, 3);
   EXPECT_EQ(4, sizes[DW_FORM_ref_addr]);
   // Check that we don't have fixed form sizes for weird address sizes.
   EXPECT_EQ(0U, DWARFFormValue::getFixedFormSizes(16, 2).size());
 }
 
-bool isFormClass(uint16_t Form, DWARFFormValue::FormClass FC) {
+bool isFormClass(dwarf::Form Form, DWARFFormValue::FormClass FC) {
   return DWARFFormValue(Form).isFormClass(FC);
 }
 
 TEST(DWARFFormValue, FormClass) {
   EXPECT_TRUE(isFormClass(DW_FORM_addr, DWARFFormValue::FC_Address));
   EXPECT_FALSE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Address));
   EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Constant));
   EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_SectionOffset));
   EXPECT_TRUE(
       isFormClass(DW_FORM_sec_offset, DWARFFormValue::FC_SectionOffset));
   EXPECT_TRUE(isFormClass(DW_FORM_GNU_str_index, DWARFFormValue::FC_String));
   EXPECT_TRUE(isFormClass(DW_FORM_GNU_addr_index, DWARFFormValue::FC_Address));
   EXPECT_FALSE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Address));
   EXPECT_TRUE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Reference));
   EXPECT_TRUE(isFormClass(DW_FORM_ref_sig8, DWARFFormValue::FC_Reference));
 }
 
 template<typename RawTypeT>
-DWARFFormValue createDataXFormValue(uint16_t Form, RawTypeT Value) {
+DWARFFormValue createDataXFormValue(dwarf::Form Form, RawTypeT Value) {
   char Raw[sizeof(RawTypeT)];
   memcpy(Raw, &Value, sizeof(RawTypeT));
   uint32_t Offset = 0;
   DWARFFormValue Result(Form);
   DataExtractor Data(StringRef(Raw, sizeof(RawTypeT)),
                      sys::IsLittleEndianHost, sizeof(void*));
   Result.extractValue(Data, &Offset, nullptr);
   return Result;