DWARF: Unify form size handling code

[labath]

Summary

This patch replaces the two switches which are deducing the size of
various forms with a single implementation. I have put the new
implementation into BinaryFormat, to avoid introducing dependencies
between the two independent libraries (DebugInfo and CodeGen) that need
this functionality.

[JDevlieghere]

LGTM. Thanks Pavel!

llvm/trunk/include/llvm/BinaryFormat/Dwarf.h

 /// Information Format standard document on http://www.dwarfstd.org. This
 /// file often includes support for non-released standard features.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BINARYFORMAT_DWARF_H
 #define LLVM_BINARYFORMAT_DWARF_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 class StringRef;
 
 namespace dwarf {
 
 //===----------------------------------------------------------------------===//
 // DWARF constants as gleaned from the DWARF Debugging Information Format V.5
enum LLVMConstants : uint32_t {
   DWARF_VENDOR_APPLE = 1,
   DWARF_VENDOR_BORLAND = 2,
   DWARF_VENDOR_GNU = 3,
   DWARF_VENDOR_GOOGLE = 4,
   DWARF_VENDOR_LLVM = 5,
   DWARF_VENDOR_MIPS = 6
 };
 
+/// Constants that define the DWARF format as 32 or 64 bit.
+enum DwarfFormat : uint8_t { DWARF32, DWARF64 };
+
 /// Special ID values that distinguish a CIE from a FDE in DWARF CFI.
 /// Not inside an enum because a 64-bit value is needed.
 /// @{
 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.

 unsigned TagVendor(Tag T);
 unsigned AttributeVendor(Attribute A);
 unsigned FormVendor(Form F);
 unsigned OperationVendor(LocationAtom O);
 unsigned AttributeEncodingVendor(TypeKind E);
 unsigned LanguageVendor(SourceLanguage L);
 /// @}
 
+/// A helper struct providing information about the byte size of DW_FORM
+/// values that vary in size depending on the DWARF version, address byte
+/// size, or DWARF32/DWARF64.
+struct FormParams {
+  uint16_t Version;
+  uint8_t AddrSize;
+  DwarfFormat Format;
+
+  /// The definition of the size of form DW_FORM_ref_addr depends on the
+  /// version. In DWARF v2 it's the size of an address; after that, it's the
+  /// size of a reference.
+  uint8_t getRefAddrByteSize() const {
+    if (Version == 2)
+      return AddrSize;
+    return getDwarfOffsetByteSize();
+  }
+
+  /// The size of a reference is determined by the DWARF 32/64-bit format.
+  uint8_t getDwarfOffsetByteSize() const {
+    switch (Format) {
+    case DwarfFormat::DWARF32:
+      return 4;
+    case DwarfFormat::DWARF64:
+      return 8;
+    }
+    llvm_unreachable("Invalid Format value");
+  }
+
+  explicit operator bool() const { return Version && AddrSize; }
+};
+
+/// Get the fixed byte size for a given form.
+///
+/// If the form has a fixed byte size, then an Optional with a value will be
+/// returned. If the form is always encoded using a variable length storage
+/// format (ULEB or SLEB numbers or blocks) then None will be returned.
+///
+/// \param Form DWARF form to get the fixed byte size for.
+/// \param Params DWARF parameters to help interpret forms.
+/// \returns Optional<uint8_t> value with the fixed byte size or None if
+/// \p Form doesn't have a fixed byte size.
+Optional<uint8_t> getFixedFormByteSize(dwarf::Form Form, FormParams Params);
+
 /// Tells whether the specified form is defined in the specified version,
 /// or is an extension if extensions are allowed.
 bool isValidFormForVersion(Form F, unsigned Version, bool ExtensionsOk = true);
 
 /// Returns the symbolic string representing Val when used as a value
 /// for attribute Attr.
 StringRef AttributeValueString(uint16_t Attr, unsigned Val);
 
private:
   enum {
     KIND_OFFSET = 4,
     KIND_MASK = 7 << KIND_OFFSET,
     LINKAGE_OFFSET = 7,
     LINKAGE_MASK = 1 << LINKAGE_OFFSET
   };
 };
 
-/// Constants that define the DWARF format as 32 or 64 bit.
-enum DwarfFormat : uint8_t { DWARF32, DWARF64 };
-
 } // End of namespace dwarf
 
 } // End of namespace llvm
 
 #endif

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

struct Prologue {
     Prologue();
 
     /// The size in bytes of the statement information for this compilation unit
     /// (not including the total_length field itself).
     uint64_t TotalLength;
     /// Version, address size (starting in v5), and DWARF32/64 format; these
     /// parameters affect interpretation of forms (used in the directory and
     /// file tables starting with v5).
-    DWARFFormParams FormParams;
+    dwarf::FormParams FormParams;
     /// The number of bytes following the prologue_length field to the beginning
     /// of the first byte of the statement program itself.
     uint64_t PrologueLength;
     /// In v5, size in bytes of a segment selector.
     uint8_t SegSelectorSize;
     /// The size in bytes of the smallest target machine instruction. Statement
     /// program opcodes that alter the address register first multiply their
     /// operands by this value.
struct Prologue {
     /// The number assigned to the first special opcode.
     uint8_t OpcodeBase;
     /// This tracks which optional file format content types are present.
     ContentTypeTracker ContentTypes;
     std::vector<uint8_t> StandardOpcodeLengths;
     std::vector<DWARFFormValue> IncludeDirectories;
     std::vector<FileNameEntry> FileNames;
 
-    const DWARFFormParams getFormParams() const { return FormParams; }
+    const dwarf::FormParams getFormParams() const { return FormParams; }
     uint16_t getVersion() const { return FormParams.Version; }
     uint8_t getAddressSize() const { return FormParams.AddrSize; }
     bool isDWARF64() const { return FormParams.Format == dwarf::DWARF64; }
 
     uint32_t sizeofTotalLength() const { return isDWARF64() ? 12 : 4; }
 
     uint32_t sizeofPrologueLength() const { return isDWARF64() ? 8 : 4; }
 

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

 #include <cstdint>
 
 namespace llvm {
 
 class DWARFContext;
 class DWARFUnit;
 class raw_ostream;
 
-/// A helper struct for DWARFFormValue methods, providing information that
-/// allows it to know the byte size of DW_FORM values that vary in size
-/// depending on the DWARF version, address byte size, or DWARF32/DWARF64.
-struct DWARFFormParams {
-  uint16_t Version;
-  uint8_t AddrSize;
-  dwarf::DwarfFormat Format;
-
-  /// The definition of the size of form DW_FORM_ref_addr depends on the
-  /// version. In DWARF v2 it's the size of an address; after that, it's the
-  /// size of a reference.
-  uint8_t getRefAddrByteSize() const {
-    if (Version == 2)
-      return AddrSize;
-    return getDwarfOffsetByteSize();
-  }
-
-  /// The size of a reference is determined by the DWARF 32/64-bit format.
-  uint8_t getDwarfOffsetByteSize() const {
-    switch (Format) {
-    case dwarf::DwarfFormat::DWARF32:
-      return 4;
-    case dwarf::DwarfFormat::DWARF64:
-      return 8;
-    }
-    llvm_unreachable("Invalid Format value");
-  }
-
-  explicit operator bool() const { return Version && AddrSize; }
-};
-
 class DWARFFormValue {
 public:
   enum FormClass {
     FC_Unknown,
     FC_Address,
     FC_Block,
     FC_Constant,
     FC_String,
public:
   const DWARFUnit *getUnit() const { return U; }
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = DIDumpOptions()) const;
 
   /// Extracts a value in \p Data at offset \p *OffsetPtr. The information
   /// in \p FormParams is needed to interpret some forms. The optional
   /// \p Context and \p Unit allows extracting information if the form refers
   /// to other sections (e.g., .debug_str).
   bool extractValue(const DWARFDataExtractor &Data, uint32_t *OffsetPtr,
-                    DWARFFormParams FormParams,
+                    dwarf::FormParams FormParams,
                     const DWARFContext *Context = nullptr,
                     const DWARFUnit *Unit = nullptr);
 
   bool extractValue(const DWARFDataExtractor &Data, uint32_t *OffsetPtr,
-                    DWARFFormParams FormParams, const DWARFUnit *U) {
+                    dwarf::FormParams FormParams, const DWARFUnit *U) {
     return extractValue(Data, OffsetPtr, FormParams, nullptr, U);
   }
 
   bool isInlinedCStr() const {
     return Value.data != nullptr && Value.data == (const uint8_t *)Value.cstr;
   }
 
   /// getAsFoo functions below return the extracted value as Foo if only
   /// DWARFFormValue has form class is suitable for representing Foo.
   Optional<uint64_t> getAsReference() const;
   Optional<uint64_t> getAsUnsignedConstant() const;
   Optional<int64_t> getAsSignedConstant() const;
   Optional<const char *> getAsCString() const;
   Optional<uint64_t> getAsAddress() const;
   Optional<uint64_t> getAsSectionOffset() const;
   Optional<ArrayRef<uint8_t>> getAsBlock() const;
   Optional<uint64_t> getAsCStringOffset() const;
   Optional<uint64_t> getAsReferenceUVal() const;
 
-  /// Get the fixed byte size for a given form.
-  ///
-  /// If the form has a fixed byte size, then an Optional with a value will be
-  /// returned. If the form is always encoded using a variable length storage
-  /// format (ULEB or SLEB numbers or blocks) then None will be returned.
-  ///
-  /// \param Form DWARF form to get the fixed byte size for.
-  /// \param FormParams DWARF parameters to help interpret forms.
-  /// \returns Optional<uint8_t> value with the fixed byte size or None if
-  /// \p Form doesn't have a fixed byte size.
-  static Optional<uint8_t> getFixedByteSize(dwarf::Form Form,
-                                            const DWARFFormParams FormParams);
-
   /// Skip a form's value in \p DebugInfoData at the offset specified by
   /// \p OffsetPtr.
   ///
   /// Skips the bytes for the current form and updates the offset.
   ///
   /// \param DebugInfoData The data where we want to skip the value.
   /// \param OffsetPtr A reference to the offset that will be updated.
   /// \param Params DWARF parameters to help interpret forms.
   /// \returns true on success, false if the form was not skipped.
   bool skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
-                 const DWARFFormParams Params) const {
+                 const dwarf::FormParams Params) const {
     return DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, Params);
   }
 
   /// Skip a form's value in \p DebugInfoData at the offset specified by
   /// \p OffsetPtr.
   ///
   /// Skips the bytes for the specified form and updates the offset.
   ///
   /// \param Form The DW_FORM enumeration that indicates the form to skip.
   /// \param DebugInfoData The data where we want to skip the value.
   /// \param OffsetPtr A reference to the offset that will be updated.
   /// \param FormParams DWARF parameters to help interpret forms.
   /// \returns true on success, false if the form was not skipped.
   static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
-                        uint32_t *OffsetPtr, const DWARFFormParams FormParams);
+                        uint32_t *OffsetPtr,
+                        const dwarf::FormParams FormParams);
 
 private:
   void dumpString(raw_ostream &OS) const;
 };
 
 namespace dwarf {
 
 /// Take an optional DWARFFormValue and try to extract a string value from it.

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h

struct BaseAddress {
   uint64_t SectionIndex;
 };
 
 /// Represents a unit's contribution to the string offsets table.
 struct StrOffsetsContributionDescriptor {
   uint64_t Base = 0;
   uint64_t Size = 0;
   /// Format and version.
-  DWARFFormParams FormParams = {0, 0, dwarf::DwarfFormat::DWARF32};
+  dwarf::FormParams FormParams = {0, 0, dwarf::DwarfFormat::DWARF32};
 
   StrOffsetsContributionDescriptor(uint64_t Base, uint64_t Size,
                                    uint8_t Version, dwarf::DwarfFormat Format)
       : Base(Base), Size(Size), FormParams({Version, 0, Format}) {}
 
   uint8_t getVersion() const { return FormParams.Version; }
   dwarf::DwarfFormat getFormat() const { return FormParams.Format; }
   uint8_t getDwarfOffsetByteSize() const {
class DWARFUnit {
   const DWARFSection &StringOffsetSection;
   const DWARFSection *AddrOffsetSection;
   uint32_t AddrOffsetSectionBase = 0;
   bool isLittleEndian;
   bool isDWO;
   const DWARFUnitSectionBase &UnitSection;
 
   // Version, address size, and DWARF format.
-  DWARFFormParams FormParams;
+  dwarf::FormParams FormParams;
   /// Start, length, and DWARF format of the unit's contribution to the string
   /// offsets table (DWARF v5).
   Optional<StrOffsetsContributionDescriptor> StringOffsetsTableContribution;
 
   uint32_t Offset;
   uint32_t Length;
   mutable const DWARFAbbreviationDeclarationSet *Abbrevs;
   uint64_t AbbrOffset;
public:
   uint32_t getOffset() const { return Offset; }
   uint32_t getNextUnitOffset() const { return Offset + Length + 4; }
   uint32_t getLength() const { return Length; }
 
   const Optional<StrOffsetsContributionDescriptor> &
   getStringOffsetsTableContribution() const {
     return StringOffsetsTableContribution;
   }
-  const DWARFFormParams &getFormParams() const { return FormParams; }
+  const dwarf::FormParams &getFormParams() const { return FormParams; }
   uint16_t getVersion() const { return FormParams.Version; }
   dwarf::DwarfFormat getFormat() const { return FormParams.Format; }
   uint8_t getAddressByteSize() const { return FormParams.AddrSize; }
   uint8_t getRefAddrByteSize() const { return FormParams.getRefAddrByteSize(); }
   uint8_t getDwarfOffsetByteSize() const {
     return FormParams.getDwarfOffsetByteSize();
   }
 

llvm/trunk/lib/BinaryFormat/Dwarf.cpp

default:
     return StringRef();
 #define HANDLE_DW_IDX(ID, NAME)                                                \
   case DW_IDX_##NAME:                                                          \
     return "DW_IDX_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
+Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,
+                                                    FormParams Params) {
+  switch (Form) {
+  case DW_FORM_addr:
+    if (Params)
+      return Params.AddrSize;
+    return None;
+
+  case DW_FORM_block:          // ULEB128 length L followed by L bytes.
+  case DW_FORM_block1:         // 1 byte length L followed by L bytes.
+  case DW_FORM_block2:         // 2 byte length L followed by L bytes.
+  case DW_FORM_block4:         // 4 byte length L followed by L bytes.
+  case DW_FORM_string:         // C-string with null terminator.
+  case DW_FORM_sdata:          // SLEB128.
+  case DW_FORM_udata:          // ULEB128.
+  case DW_FORM_ref_udata:      // ULEB128.
+  case DW_FORM_indirect:       // ULEB128.
+  case DW_FORM_exprloc:        // ULEB128 length L followed by L bytes.
+  case DW_FORM_strx:           // ULEB128.
+  case DW_FORM_addrx:          // ULEB128.
+  case DW_FORM_loclistx:       // ULEB128.
+  case DW_FORM_rnglistx:       // ULEB128.
+  case DW_FORM_GNU_addr_index: // ULEB128.
+  case DW_FORM_GNU_str_index:  // ULEB128.
+    return None;
+
+  case DW_FORM_ref_addr:
+    if (Params)
+      return Params.getRefAddrByteSize();
+    return None;
+
+  case DW_FORM_flag:
+  case DW_FORM_data1:
+  case DW_FORM_ref1:
+  case DW_FORM_strx1:
+  case DW_FORM_addrx1:
+    return 1;
+
+  case DW_FORM_data2:
+  case DW_FORM_ref2:
+  case DW_FORM_strx2:
+  case DW_FORM_addrx2:
+    return 2;
+
+  case DW_FORM_strx3:
+    return 3;
+
+  case DW_FORM_data4:
+  case DW_FORM_ref4:
+  case DW_FORM_ref_sup4:
+  case DW_FORM_strx4:
+  case DW_FORM_addrx4:
+    return 4;
+
+  case DW_FORM_strp:
+  case DW_FORM_GNU_ref_alt:
+  case DW_FORM_GNU_strp_alt:
+  case DW_FORM_line_strp:
+  case DW_FORM_sec_offset:
+  case DW_FORM_strp_sup:
+    if (Params)
+      return Params.getDwarfOffsetByteSize();
+    return None;
+
+  case DW_FORM_data8:
+  case DW_FORM_ref8:
+  case DW_FORM_ref_sig8:
+  case DW_FORM_ref_sup8:
+    return 8;
+
+  case DW_FORM_flag_present:
+    return 0;
+
+  case DW_FORM_data16:
+    return 16;
+
+  case DW_FORM_implicit_const:
+    // The implicit value is stored in the abbreviation as a SLEB128, and
+    // there no data in debug info.
+    return 0;
+
+  default:
+    break;
+  }
+  return None;
+}
+
 bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
                                         bool ExtensionsOk) {
   if (FormVendor(F) == DWARF_VENDOR_DWARF) {
     unsigned FV = FormVersion(F);
     return FV > 0 && FV <= Version;
   }
   return ExtensionsOk;
 }

llvm/trunk/lib/CodeGen/AsmPrinter/DIE.cpp

case dwarf::DW_FORM_sdata:
     return;
   default: llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 /// SizeOf - Determine size of integer value in bytes.
 ///
 unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+  dwarf::FormParams Params;
+  if (AP)
+    Params = {AP->getDwarfVersion(), uint8_t(AP->getPointerSize()),
+              AP->OutStreamer->getContext().getDwarfFormat()};
+
+  if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params))
+    return *FixedSize;
+
   switch (Form) {
-  case dwarf::DW_FORM_implicit_const:
-  case dwarf::DW_FORM_flag_present:
-    return 0;
-  case dwarf::DW_FORM_flag:
-  case dwarf::DW_FORM_ref1:
-  case dwarf::DW_FORM_data1:
-  case dwarf::DW_FORM_strx1:
-  case dwarf::DW_FORM_addrx1:
-    return sizeof(int8_t);
-  case dwarf::DW_FORM_ref2:
-  case dwarf::DW_FORM_data2:
-  case dwarf::DW_FORM_strx2:
-  case dwarf::DW_FORM_addrx2:
-    return sizeof(int16_t);
-  case dwarf::DW_FORM_strx3:
-    return 3;
-  case dwarf::DW_FORM_ref4:
-  case dwarf::DW_FORM_data4:
-  case dwarf::DW_FORM_ref_sup4:
-  case dwarf::DW_FORM_strx4:
-  case dwarf::DW_FORM_addrx4:
-    return sizeof(int32_t);
-  case dwarf::DW_FORM_ref8:
-  case dwarf::DW_FORM_ref_sig8:
-  case dwarf::DW_FORM_data8:
-  case dwarf::DW_FORM_ref_sup8:
-    return sizeof(int64_t);
-  case dwarf::DW_FORM_ref_addr:
-    if (AP->getDwarfVersion() == 2)
-      return AP->getPointerSize();
-    LLVM_FALLTHROUGH;
-  case dwarf::DW_FORM_strp:
-  case dwarf::DW_FORM_GNU_ref_alt:
-  case dwarf::DW_FORM_GNU_strp_alt:
-  case dwarf::DW_FORM_line_strp:
-  case dwarf::DW_FORM_sec_offset:
-  case dwarf::DW_FORM_strp_sup:
-    switch (AP->OutStreamer->getContext().getDwarfFormat()) {
-    case dwarf::DWARF32:
-      return 4;
-    case dwarf::DWARF64:
-      return 8;
-    }
-    llvm_unreachable("Invalid DWARF format");
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_GNU_addr_index:
   case dwarf::DW_FORM_ref_udata:
   case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_udata:
     return getULEB128Size(Integer);
   case dwarf::DW_FORM_sdata:
     return getSLEB128Size(Integer);
-  case dwarf::DW_FORM_addr:
-    return AP->getPointerSize();
   default: llvm_unreachable("DIE Value form not supported yet");
   }
 }
 
 LLVM_DUMP_METHOD
 void DIEInteger::print(raw_ostream &O) const {
   O << "Int: " << (int64_t)Integer << "  0x";
   O.write_hex(Integer);

llvm/trunk/lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

if (A && F) {
       case DW_FORM_strp_sup:
         if (FixedAttributeSize)
           ++FixedAttributeSize->NumDwarfOffsets;
         break;
 
       default:
         // The form has a byte size that doesn't depend on Params.
         // If it's a fixed size, keep track of it.
-        if ((ByteSize =
-                 DWARFFormValue::getFixedByteSize(F, DWARFFormParams()))) {
+        if ((ByteSize = dwarf::getFixedFormByteSize(F, dwarf::FormParams()))) {
           if (FixedAttributeSize)
             FixedAttributeSize->NumBytes += *ByteSize;
           break;
         }
         // Indicate we no longer have a fixed byte size for this
         // abbreviation by clearing the FixedAttributeSize optional value
         // so it doesn't have a value.
         FixedAttributeSize.reset();

 
 Optional<int64_t> DWARFAbbreviationDeclaration::AttributeSpec::getByteSize(
     const DWARFUnit &U) const {
   if (isImplicitConst())
     return 0;
   if (ByteSize.HasByteSize)
     return ByteSize.ByteSize;
   Optional<int64_t> S;
-  auto FixedByteSize =
-      DWARFFormValue::getFixedByteSize(Form, U.getFormParams());
+  auto FixedByteSize = dwarf::getFixedFormByteSize(Form, U.getFormParams());
   if (FixedByteSize)
     S = *FixedByteSize;
   return S;
 }
 
 Optional<size_t> DWARFAbbreviationDeclaration::getFixedAttributesByteSize(
     const DWARFUnit &U) const {
   if (FixedAttributeSize)
     return FixedAttributeSize->getByteSize(U);
   return None;
 }

llvm/trunk/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

bool AppleAcceleratorTable::validateForms() {
   }
   return true;
 }
 
 std::pair<uint32_t, dwarf::Tag>
 AppleAcceleratorTable::readAtoms(uint32_t &HashDataOffset) {
   uint32_t DieOffset = dwarf::DW_INVALID_OFFSET;
   dwarf::Tag DieTag = dwarf::DW_TAG_null;
-  DWARFFormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
+  dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
 
   for (auto Atom : getAtomsDesc()) {
     DWARFFormValue FormValue(Atom.second);
     FormValue.extractValue(AccelSection, &HashDataOffset, FormParams);
     switch (Atom.first) {
     case dwarf::DW_ATOM_die_offset:
       DieOffset = *FormValue.getAsUnsignedConstant();
       break;
Optional<uint64_t> AppleAcceleratorTable::HeaderData::extractOffset(
   default:
     return Value->getAsSectionOffset();
   }
 }
 
 bool AppleAcceleratorTable::dumpName(ScopedPrinter &W,
                                      SmallVectorImpl<DWARFFormValue> &AtomForms,
                                      uint32_t *DataOffset) const {
-  DWARFFormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
+  dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
   uint32_t NameOffset = *DataOffset;
   if (!AccelSection.isValidOffsetForDataOfSize(*DataOffset, 4)) {
     W.printString("Incorrectly terminated list.");
     return false;
   }
   unsigned StringOffset = AccelSection.getRelocatedValue(4, DataOffset);
   if (!StringOffset)
     return false; // End of list
AppleAcceleratorTable::Entry::Entry(
   Values.reserve(HdrData.Atoms.size());
   for (const auto &Atom : HdrData.Atoms)
     Values.push_back(DWARFFormValue(Atom.second));
 }
 
 void AppleAcceleratorTable::Entry::extract(
     const AppleAcceleratorTable &AccelTable, uint32_t *Offset) {
 
-  DWARFFormParams FormParams = {AccelTable.Hdr.Version, 0,
+  dwarf::FormParams FormParams = {AccelTable.Hdr.Version, 0,
                                   dwarf::DwarfFormat::DWARF32};
   for (auto &Atom : Values)
     Atom.extractValue(AccelTable.AccelSection, Offset, FormParams);
 }
 
 Optional<DWARFFormValue>
 AppleAcceleratorTable::Entry::lookup(HeaderData::AtomType Atom) const {
   assert(HdrData && "Dereferencing end iterator?");
   assert(HdrData->Atoms.size() == Values.size());
DWARFDebugNames::NameIndex::getEntry(uint32_t *Offset) const {
 
   const auto AbbrevIt = Abbrevs.find_as(AbbrevCode);
   if (AbbrevIt == Abbrevs.end())
     return make_error<StringError>("Invalid abbreviation",
                                    inconvertibleErrorCode());
 
   Entry E(*this, *AbbrevIt);
 
-  DWARFFormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
+  dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
   for (auto &Value : E.Values) {
     if (!Value.extractValue(AS, Offset, FormParams))
       return make_error<StringError>("Error extracting index attribute values",
                                      inconvertibleErrorCode());
   }
   return std::move(E);
 }
 

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

 
 DWARFDebugLine::Prologue::Prologue() { clear(); }
 
 void DWARFDebugLine::Prologue::clear() {
   TotalLength = PrologueLength = 0;
   SegSelectorSize = 0;
   MinInstLength = MaxOpsPerInst = DefaultIsStmt = LineBase = LineRange = 0;
   OpcodeBase = 0;
-  FormParams = DWARFFormParams({0, 0, DWARF32});
+  FormParams = dwarf::FormParams({0, 0, DWARF32});
   ContentTypes = ContentTypeTracker();
   StandardOpcodeLengths.clear();
   IncludeDirectories.clear();
   FileNames.clear();
 }
 
 void DWARFDebugLine::Prologue::dump(raw_ostream &OS,
                                     DIDumpOptions DumpOptions) const {
for (int I = 0; I != FormatCount; ++I) {
     Descriptors.push_back(Descriptor);
   }
   return HasPath ? Descriptors : ContentDescriptors();
 }
 
 static bool
 parseV5DirFileTables(const DWARFDataExtractor &DebugLineData,
                      uint32_t *OffsetPtr, uint64_t EndPrologueOffset,
-                     const DWARFFormParams &FormParams, const DWARFContext
-                     &Ctx, const DWARFUnit *U,
+                     const dwarf::FormParams &FormParams,
+                     const DWARFContext &Ctx, const DWARFUnit *U,
                      DWARFDebugLine::ContentTypeTracker &ContentTypes,
                      std::vector<DWARFFormValue> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   // Get the directory entry description.
   ContentDescriptors DirDescriptors =
       parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset, nullptr);
   if (DirDescriptors.empty())
     return false;

llvm/trunk/lib/DebugInfo/DWARF/DWARFFormValue.cpp

static const DWARFFormValue::FormClass DWARF5FormClasses[] = {
     DWARFFormValue::FC_String,        // 0x28 DW_FORM_strx4
     DWARFFormValue::FC_Address,       // 0x29 DW_FORM_addrx1
     DWARFFormValue::FC_Address,       // 0x2a DW_FORM_addrx2
     DWARFFormValue::FC_Address,       // 0x2b DW_FORM_addrx3
     DWARFFormValue::FC_Address,       // 0x2c DW_FORM_addrx4
 
 };
 
-Optional<uint8_t>
-DWARFFormValue::getFixedByteSize(dwarf::Form Form,
-                                 const DWARFFormParams Params) {
-  switch (Form) {
-  case DW_FORM_addr:
-    if (Params)
-      return Params.AddrSize;
-    return None;
-
-  case DW_FORM_block:          // ULEB128 length L followed by L bytes.
-  case DW_FORM_block1:         // 1 byte length L followed by L bytes.
-  case DW_FORM_block2:         // 2 byte length L followed by L bytes.
-  case DW_FORM_block4:         // 4 byte length L followed by L bytes.
-  case DW_FORM_string:         // C-string with null terminator.
-  case DW_FORM_sdata:          // SLEB128.
-  case DW_FORM_udata:          // ULEB128.
-  case DW_FORM_ref_udata:      // ULEB128.
-  case DW_FORM_indirect:       // ULEB128.
-  case DW_FORM_exprloc:        // ULEB128 length L followed by L bytes.
-  case DW_FORM_strx:           // ULEB128.
-  case DW_FORM_addrx:          // ULEB128.
-  case DW_FORM_loclistx:       // ULEB128.
-  case DW_FORM_rnglistx:       // ULEB128.
-  case DW_FORM_GNU_addr_index: // ULEB128.
-  case DW_FORM_GNU_str_index:  // ULEB128.
-    return None;
-
-  case DW_FORM_ref_addr:
-    if (Params)
-      return Params.getRefAddrByteSize();
-    return None;
-
-  case DW_FORM_flag:
-  case DW_FORM_data1:
-  case DW_FORM_ref1:
-  case DW_FORM_strx1:
-  case DW_FORM_addrx1:
-    return 1;
-
-  case DW_FORM_data2:
-  case DW_FORM_ref2:
-  case DW_FORM_strx2:
-  case DW_FORM_addrx2:
-    return 2;
-
-  case DW_FORM_strx3:
-    return 3;
-
-  case DW_FORM_data4:
-  case DW_FORM_ref4:
-  case DW_FORM_ref_sup4:
-  case DW_FORM_strx4:
-  case DW_FORM_addrx4:
-    return 4;
-
-  case DW_FORM_strp:
-  case DW_FORM_GNU_ref_alt:
-  case DW_FORM_GNU_strp_alt:
-  case DW_FORM_line_strp:
-  case DW_FORM_sec_offset:
-  case DW_FORM_strp_sup:
-    if (Params)
-      return Params.getDwarfOffsetByteSize();
-    return None;
-
-  case DW_FORM_data8:
-  case DW_FORM_ref8:
-  case DW_FORM_ref_sig8:
-  case DW_FORM_ref_sup8:
-    return 8;
-
-  case DW_FORM_flag_present:
-    return 0;
-
-  case DW_FORM_data16:
-    return 16;
-
-  case DW_FORM_implicit_const:
-    // The implicit value is stored in the abbreviation as a SLEB128, and
-    // there no data in debug info.
-    return 0;
-
-  default:
-    break;
-  }
-  return None;
-}
-
 bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
                                uint32_t *OffsetPtr,
-                               const DWARFFormParams Params) {
+                               const dwarf::FormParams Params) {
   bool Indirect = false;
   do {
     switch (Form) {
     // Blocks of 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 = DebugInfoData.getULEB128(OffsetPtr);
do {
     case DW_FORM_addrx4:
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
     case DW_FORM_strp_sup:
     case DW_FORM_line_strp:
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_GNU_strp_alt:
       if (Optional<uint8_t> FixedSize =
-              DWARFFormValue::getFixedByteSize(Form, Params)) {
+              dwarf::getFixedFormByteSize(Form, Params)) {
         *OffsetPtr += *FixedSize;
         return true;
       }
       return false;
 
     // signed or unsigned LEB 128 values.
     case DW_FORM_sdata:
       DebugInfoData.getSLEB128(OffsetPtr);
bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   // by mistake. Also accept DW_FORM_[line_]strp since these are
   // .debug_[line_]str section offsets.
   return (Form == DW_FORM_data4 || Form == DW_FORM_data8 ||
           Form == DW_FORM_strp || Form == DW_FORM_line_strp) &&
          FC == FC_SectionOffset;
 }
 
 bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
-                                  uint32_t *OffsetPtr, DWARFFormParams FP,
+                                  uint32_t *OffsetPtr, dwarf::FormParams FP,
                                   const DWARFContext *Ctx,
                                   const DWARFUnit *CU) {
   if (!Ctx && CU)
     Ctx = &CU->getContext();
   C = Ctx;
   U = CU;
   bool Indirect = false;
   bool IsBlock = false;

llvm/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp

bool DWARFUnit::extractRangeList(uint32_t RangeListOffset,
   uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
   return RangeList.extract(RangesData, &ActualRangeListOffset);
 }
 
 void DWARFUnit::clear() {
   Offset = 0;
   Length = 0;
   Abbrevs = nullptr;
-  FormParams = DWARFFormParams({0, 0, DWARF32});
+  FormParams = dwarf::FormParams({0, 0, DWARF32});
   BaseAddr.reset();
   RangeSectionBase = 0;
   AddrOffsetSectionBase = 0;
   clearDIEs(false);
   DWO.reset();
 }
 
 const char *DWARFUnit::getCompilationDir() {

llvm/trunk/tools/llvm-dwp/llvm-dwp.cpp

case dwarf::DW_AT_GNU_dwo_name: {
       ID.DWOName = *EName;
       break;
     }
     case dwarf::DW_AT_GNU_dwo_id:
       ID.Signature = InfoData.getU64(&Offset);
       break;
     default:
       DWARFFormValue::skipValue(Form, InfoData, &Offset,
-                                DWARFFormParams({Version, AddrSize, Format}));
+                                dwarf::FormParams({Version, AddrSize, Format}));
     }
   }
   return ID;
 }
 
 struct UnitIndexEntry {
   DWARFUnitIndex::Entry::SectionContribution Contributions[8];
   std::string Name;

llvm/trunk/unittests/BinaryFormat/DwarfTest.cpp

EXPECT_EQ(DW_VIRTUALITY_pure_virtual,
             getVirtuality("DW_VIRTUALITY_pure_virtual"));
 
   // Invalid strings.
   EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("DW_VIRTUALITY_invalid"));
   EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("DW_VIRTUALITY_max"));
   EXPECT_EQ(DW_VIRTUALITY_invalid, getVirtuality("something else"));
 }
 
+TEST(DwarfTest, FixedFormSizes) {
+  Optional<uint8_t> RefSize;
+  Optional<uint8_t> AddrSize;
+
+  // Test 32 bit DWARF version 2 with 4 byte addresses.
+  FormParams Params_2_4_32 = {2, 4, DWARF32};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32);
+  AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(AddrSize.hasValue());
+  EXPECT_EQ(*RefSize, *AddrSize);
+
+  // Test 32 bit DWARF version 2 with 8 byte addresses.
+  FormParams Params_2_8_32 = {2, 8, DWARF32};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32);
+  AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(AddrSize.hasValue());
+  EXPECT_EQ(*RefSize, *AddrSize);
+
+  // DW_FORM_ref_addr is 4 bytes in DWARF 32 in DWARF version 3 and beyond.
+  FormParams Params_3_4_32 = {3, 4, DWARF32};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_4_32);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_EQ(*RefSize, 4);
+
+  FormParams Params_4_4_32 = {4, 4, DWARF32};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_4_32);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_EQ(*RefSize, 4);
+
+  FormParams Params_5_4_32 = {5, 4, DWARF32};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_4_32);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_EQ(*RefSize, 4);
+
+  // DW_FORM_ref_addr is 8 bytes in DWARF 64 in DWARF version 3 and beyond.
+  FormParams Params_3_8_64 = {3, 8, DWARF64};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_8_64);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_EQ(*RefSize, 8);
+
+  FormParams Params_4_8_64 = {4, 8, DWARF64};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_8_64);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_EQ(*RefSize, 8);
+
+  FormParams Params_5_8_64 = {5, 8, DWARF64};
+  RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_8_64);
+  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_EQ(*RefSize, 8);
+}
+
 } // end namespace

llvm/trunk/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp

 #include "llvm/Support/LEB128.h"
 #include "gtest/gtest.h"
 #include <climits>
 using namespace llvm;
 using namespace dwarf;
 
 namespace {
 
-TEST(DWARFFormValue, FixedFormSizes) {
-  Optional<uint8_t> RefSize;
-  Optional<uint8_t> AddrSize;
-
-  // Test 32 bit DWARF version 2 with 4 byte addresses.
-  DWARFFormParams Params_2_4_32 = {2, 4, DWARF32};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_2_4_32);
-  AddrSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_2_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_TRUE(AddrSize.hasValue());
-  EXPECT_EQ(*RefSize, *AddrSize);
-
-  // Test 32 bit DWARF version 2 with 8 byte addresses.
-  DWARFFormParams Params_2_8_32 = {2, 8, DWARF32};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_2_8_32);
-  AddrSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_2_8_32);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_TRUE(AddrSize.hasValue());
-  EXPECT_EQ(*RefSize, *AddrSize);
-
-  // DW_FORM_ref_addr is 4 bytes in DWARF 32 in DWARF version 3 and beyond.
-  DWARFFormParams Params_3_4_32 = {3, 4, DWARF32};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_3_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_EQ(*RefSize, 4);
-
-  DWARFFormParams Params_4_4_32 = {4, 4, DWARF32};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_4_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_EQ(*RefSize, 4);
-
-  DWARFFormParams Params_5_4_32 = {5, 4, DWARF32};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_5_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_EQ(*RefSize, 4);
-
-  // DW_FORM_ref_addr is 8 bytes in DWARF 64 in DWARF version 3 and beyond.
-  DWARFFormParams Params_3_8_64 = {3, 8, DWARF64};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_3_8_64);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_EQ(*RefSize, 8);
-
-  DWARFFormParams Params_4_8_64 = {4, 8, DWARF64};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_4_8_64);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_EQ(*RefSize, 8);
-
-  DWARFFormParams Params_5_8_64 = {5, 8, DWARF64};
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, Params_5_8_64);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_EQ(*RefSize, 8);
-}
-
 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));