[DWARF] NFC: Collect info needed by DWARFFormValue into a helper

[probinson]

Summary

The size of the value described by a form can depend on DWARF format (32/64-bit), DWARF version, or the size of a target address. Collect these parameters into a class to make it simpler to pass them around, and have just one place to define query methods that understand the effect of the parameters on form sizes.

Inspired by review comments on D33155. This patch seemed worth splitting out as it was a bunch of typing and fiddled with an API, while still being NFC. A subsequent step would be to collect up the section references needed for retrieving the value (as opposed to the size) of the attribute described be the form, which should finish the job of making DWARFFormValue agnostic to whether the data comes from a "unit" or a line-table section.

[probinson]

As a follow-up, I was thinking that the DwarfFormat enum could be given a 1-byte base type (given that it has only two values), which would make DWARFFormParams only 4 bytes, which would make it reasonable to pass around by value instead of by reference.

[dblaikie]

Other than simplifying the DWARFFormParams a bit, this seems good to me.

(if DWARFAbbreviationDeclaration::extract is the only place that doesn't pass these extra params - maybe force that caller to construct a default DWARFFormParams, and remove the optionality from the primary API to avoid new callers neglecting to pass this important thing (& leave a comment there explaining that DWARF might need to be improved so that's supported? Or if it's supported & LLVM's parsing is missing functionality, a comment about that (about how parsing abbrevs can't be done without knowing the unit (& its address size, etc) that is specified there))

& shrinking the enum/passing by value seems fine by me in a followup if you like

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

29–63 ↗

(On Diff #103755)

This seems like a bit more encapsulation than I'd expect/seems warranted for a few parameters.

Especially the protected ctor, imho - it doesn't change any invariants of the class (the 3-arg ctor can be used to construct a default constructed object) & doesn't seem to protect from any really trivial misuse.

Also the 3-arg ctor would be about as good as braced init, and the value can be changed at any time with assignment anyway - maybe make this a struct? & leave the getRefAddrByteSize+getDwarfOffsetByteSize member functions for convenience - but I'd strip the rest of the accessors/ctors/friending out and make it a struct.

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

64 ↗

(On Diff #103755)

Should this be optional? The only place that doesn't pass it looks to be DWARFAbbreviationDeclaration::extract - is that usage correct? Does the abbrev table implicit_const not support the extra features? Should there be some error path/check for any forms that would require the params?

[probinson]

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

29–63 ↗

(On Diff #103755)

Yeah, I waffled on that. I'll simplify.
So to be clear, you're suggesting eliminating the 3-arg ctor as well?

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

64 ↗

(On Diff #103755)

There is a use-case for scanning the abbreviations table to determine which ones are fixed-size in all cases. And the abbreviations table can be shared by units/line-tables with different formats/versions. This was an important point for @clayborg and LLDB, I think.
So yes, I think it should remain optional. We can change our minds later if I'm wrong.

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

 //===- DWARFDebugLine.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_DWARFDEBUGLINE_H
 #define LLVM_DEBUGINFO_DWARFDEBUGLINE_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/DataExtractor.h"
 #include <cstdint>
 #include <map>
 #include <string>
 #include <vector>
 
 namespace llvm {
public:
   };
 
   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 identifier for the statement information format.
-    uint16_t Version;
-    /// In v5, size in bytes of an address (or segment offset).
-    uint8_t AddressSize;
+    /// 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;
     /// In v5, size in bytes of a segment selector.
     uint8_t SegSelectorSize;
     /// The number of bytes following the prologue_length field to the beginning
     /// of the first byte of the statement program itself.
     uint64_t PrologueLength;
     /// 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.
     uint8_t MinInstLength;
     /// The maximum number of individual operations that may be encoded in an
     /// instruction.
     uint8_t MaxOpsPerInst;
     /// The initial value of theis_stmtregister.
     uint8_t DefaultIsStmt;
     /// This parameter affects the meaning of the special opcodes. See below.
     int8_t LineBase;
     /// This parameter affects the meaning of the special opcodes. See below.
     uint8_t LineRange;
     /// The number assigned to the first special opcode.
     uint8_t OpcodeBase;
     std::vector<uint8_t> StandardOpcodeLengths;
     std::vector<StringRef> IncludeDirectories;
     std::vector<FileNameEntry> FileNames;
 
-    bool IsDWARF64;
+    const DWARFFormParams 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 sizeofTotalLength() const { return isDWARF64() ? 12 : 4; }
 
-    uint32_t sizeofPrologueLength() const { return IsDWARF64 ? 8 : 4; }
+    uint32_t sizeofPrologueLength() const { return isDWARF64() ? 8 : 4; }
 
     /// Length of the prologue in bytes.
     uint32_t getLength() const {
-      return PrologueLength + sizeofTotalLength() + sizeof(Version) +
+      return PrologueLength + sizeofTotalLength() + sizeof(getVersion()) +
              sizeofPrologueLength();
     }
 
     /// Length of the line table data in bytes (not including the prologue).
     uint32_t getStatementTableLength() const {
       return TotalLength + sizeofTotalLength() - getLength();
     }
 

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

 #include "llvm/Support/DataExtractor.h"
 #include <cstdint>
 
 namespace llvm {
 
 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");
+  }
+};
+
 class DWARFFormValue {
 public:
   enum FormClass {
     FC_Unknown,
     FC_Address,
     FC_Block,
     FC_Constant,
     FC_String,
public:
   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 always has a fixed valid byte size that doesn't depend on a
-  /// DWARFUnit, then an Optional with a value will be returned. If the form
-  /// can vary in size depending on the DWARFUnit (DWARF version, address byte
-  /// size, or DWARF 32/64) and the DWARFUnit is valid, then an Optional with a
-  /// valid value is returned. If the form is always encoded using a variable
-  /// length storage format (ULEB or SLEB numbers or blocks) or the size
-  /// depends on a DWARFUnit and the DWARFUnit is NULL, then None will be
-  /// returned.
-  /// \param Form The DWARF form to get the fixed byte size for
-  /// \param U The DWARFUnit that can be used to help determine the byte size.
+  /// 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.
   ///
-  /// \returns Optional<uint8_t> value with the fixed byte size or None if
-  /// \p Form doesn't have a fixed byte size or a DWARFUnit wasn't supplied
-  /// and was needed to calculate the byte size.
-  static Optional<uint8_t> getFixedByteSize(dwarf::Form Form,
-                                            const DWARFUnit *U = nullptr);
-
-  /// Get the fixed byte size for a given form.
-  ///
-  /// If the form has a fixed byte size given a valid DWARF version and address
-  /// byte size, then an Optional with a valid value is 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 Version DWARF version number.
-  /// \param AddrSize size of an address in bytes.
-  /// \param Format enum value from llvm::dwarf::DwarfFormat.
+  /// \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, uint16_t Version,
-                                            uint8_t AddrSize,
-                                            llvm::dwarf::DwarfFormat Format);
-
-  /// Skip a form in \p DebugInfoData at offset specified by \p OffsetPtr.
-  ///
-  /// Skips the bytes for this form in the debug info and updates the offset.
-  ///
-  /// \param DebugInfoData the .debug_info data to use to skip the value.
-  /// \param OffsetPtr a reference to the offset that will be updated.
-  /// \param U the DWARFUnit to use when skipping the form in case the form
-  /// size differs according to data in the DWARFUnit.
-  /// \returns true on success, false if the form was not skipped.
-  bool skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
-                 const DWARFUnit *U) const;
+  static Optional<uint8_t> getFixedByteSize(dwarf::Form Form,
+                                            const DWARFFormParams &FormParams);
 
-  /// Skip a form in \p DebugInfoData at offset specified by \p OffsetPtr.
+  /// Skip a form's value in \p DebugInfoData at the offset specified by
+  /// \p OffsetPtr.
   ///
-  /// Skips the bytes for this form in the debug info and updates the offset.
+  /// Skips the bytes for the current form and updates the offset.
   ///
-  /// \param Form the DW_FORM enumeration that indicates the form to skip.
-  /// \param DebugInfoData the .debug_info data to use to skip the value.
-  /// \param OffsetPtr a reference to the offset that will be updated.
-  /// \param U the DWARFUnit to use when skipping the form in case the form
-  /// size differs according to data in the DWARFUnit.
+  /// \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.
-  static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
-                        uint32_t *OffsetPtr, const DWARFUnit *U);
+  bool skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
+                 const DWARFFormParams &Params) const {
+    return DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, Params);
+  }
 
-  /// Skip a form in \p DebugInfoData at offset specified by \p OffsetPtr.
+  /// Skip a form's value in \p DebugInfoData at the offset specified by
+  /// \p OffsetPtr.
   ///
-  /// Skips the bytes for this form in the debug info and updates the offset.
+  /// 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 .debug_info data to use to skip the value.
-  /// \param OffsetPtr a reference to the offset that will be updated.
-  /// \param Version DWARF version number.
-  /// \param AddrSize size of an address in bytes.
-  /// \param Format enum value from llvm::dwarf::DwarfFormat.
+  /// \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, uint16_t Version, uint8_t AddrSize,
-                        llvm::dwarf::DwarfFormat Format);
+                        uint32_t *OffsetPtr, const DWARFFormParams &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

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/Support/DataExtractor.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
class DWARFUnit {
   const DWARFSection &StringOffsetSection;
   uint64_t StringOffsetSectionBase = 0;
   const DWARFSection *AddrOffsetSection;
   uint32_t AddrOffsetSectionBase;
   bool isLittleEndian;
   bool isDWO;
   const DWARFUnitSectionBase &UnitSection;
 
+  // Version, address size, and DWARF format.
+  DWARFFormParams FormParams;
+
   uint32_t Offset;
   uint32_t Length;
   const DWARFAbbreviationDeclarationSet *Abbrevs;
-  uint16_t Version;
   uint8_t UnitType;
-  uint8_t AddrSize;
   uint64_t BaseAddr;
   /// The compile unit debug information entry items.
   std::vector<DWARFDebugInfoEntry> DieArray;
 
   /// Map from range's start address to end address and corresponding DIE.
   /// IntervalMap does not support range removal, as a result, we use the
   /// std::map::upper_bound for address range lookup.
   std::map<uint64_t, std::pair<uint64_t, DWARFDie>> AddrDieMap;
uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) {
     assert(Die >= First && Die < First + DieArray.size());
     return Die - First;
   }
 
 protected:
   virtual bool extractImpl(DataExtractor debug_info, uint32_t *offset_ptr);
 
   /// Size in bytes of the unit header.
-  virtual uint32_t getHeaderSize() const { return Version <= 4 ? 11 : 12; }
+  virtual uint32_t getHeaderSize() const { return getVersion() <= 4 ? 11 : 12; }
 
 public:
   DWARFUnit(DWARFContext &Context, const DWARFSection &Section,
             const DWARFDebugAbbrev *DA, const DWARFSection *RS, StringRef SS,
             const DWARFSection &SOS, const DWARFSection *AOS, StringRef LS,
             bool LE, bool IsDWO, const DWARFUnitSectionBase &UnitSection,
             const DWARFUnitIndex::Entry *IndexEntry = nullptr);
 
public:
   }
 
   bool getAddrOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
   // FIXME: Result should be uint64_t in DWARF64.
   bool getStringOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
   uint64_t getStringOffsetSectionRelocation(uint32_t Index) const;
 
   DataExtractor getDebugInfoExtractor() const {
-    return DataExtractor(InfoSection.Data, isLittleEndian, AddrSize);
+    return DataExtractor(InfoSection.Data, isLittleEndian,
+                         getAddressByteSize());
   }
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
   const RelocAddrMap *getRelocMap() const { return &InfoSection.Relocs; }
   const RelocAddrMap &getStringOffsetsRelocMap() const {
     return StringOffsetSection.Relocs;
   }
 
   bool extract(DataExtractor debug_info, uint32_t* offset_ptr);
 
   /// extractRangeList - extracts the range list referenced by this compile
   /// unit from .debug_ranges section. Returns true on success.
   /// Requires that compile unit is already extracted.
   bool extractRangeList(uint32_t RangeListOffset,
                         DWARFDebugRangeList &RangeList) const;
   void clear();
   uint32_t getOffset() const { return Offset; }
   uint32_t getNextUnitOffset() const { return Offset + Length + 4; }
   uint32_t getLength() const { return Length; }
-  uint16_t getVersion() const { return Version; }
 
-  dwarf::DwarfFormat getFormat() const {
-    return dwarf::DwarfFormat::DWARF32; // FIXME: Support DWARF64.
+  const DWARFFormParams &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();
   }
 
   const DWARFAbbreviationDeclarationSet *getAbbreviations() const {
     return Abbrevs;
   }
 
   uint8_t getUnitType() const { return UnitType; }
-  uint8_t getAddressByteSize() const { return AddrSize; }
-
-  uint8_t getRefAddrByteSize() const {
-    if (Version == 2)
-      return AddrSize;
-    return getDwarfOffsetByteSize();
-  }
-
-  uint8_t getDwarfOffsetByteSize() const {
-    if (getFormat() == dwarf::DwarfFormat::DWARF64)
-      return 8;
-    return 4;
-  }
 
   uint64_t getBaseAddress() const { return BaseAddr; }
 
   void setBaseAddress(uint64_t base_addr) {
     BaseAddr = base_addr;
   }
 
   DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {

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

DWARFAbbreviationDeclaration::extract(DataExtractor Data,
 
   // Read all of the abbreviation attributes and forms.
   while (true) {
     auto A = static_cast<Attribute>(Data.getULEB128(OffsetPtr));
     auto F = static_cast<Form>(Data.getULEB128(OffsetPtr));
     if (A && F) {
       Optional<int64_t> V;
       bool IsImplicitConst = (F == DW_FORM_implicit_const);
-      if (IsImplicitConst)
+      if (IsImplicitConst) {
         V = Data.getSLEB128(OffsetPtr);
-      else if (auto Size = DWARFFormValue::getFixedByteSize(F))
-        V = *Size;
         AttributeSpecs.push_back(AttributeSpec(A, F, V));
-      if (IsImplicitConst)
         continue;
+      }
       // If this abbrevation still has a fixed byte size, then update the
       // FixedAttributeSize as needed.
-      if (FixedAttributeSize) {
-        if (V)
-          FixedAttributeSize->NumBytes += *V;
-        else {
-          switch (F) {
-          case DW_FORM_addr:
-            ++FixedAttributeSize->NumAddrs;
-            break;
+        if (FixedAttributeSize)
 
-          case DW_FORM_ref_addr:
-            ++FixedAttributeSize->NumRefAddrs;
-            break;
+        if (FixedAttributeSize)
 
-          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:
-            ++FixedAttributeSize->NumDwarfOffsets;
-            break;
+        if (FixedAttributeSize)
 
-          default:
-            // 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();
-            break;
-          }
-        }
-      }
+        // The form has a byte size that doesn't depend on Params.
+        // If it's a fixed size, keep track of it.
+        if (auto Size =
+                DWARFFormValue::getFixedByteSize(F, DWARFFormParams())) {
+          V = *Size;
+          if (FixedAttributeSize)
+            FixedAttributeSize->NumBytes += *V;
+          break;
+        }
+      // Record this attribute and its fixed size if it has one.
+      AttributeSpecs.push_back(AttributeSpec(A, F, V));
     } else if (A == 0 && F == 0) {
       // We successfully reached the end of this abbreviation declaration
       // since both attribute and form are zero.
       break;
     } else {
       // Attribute and form pairs must either both be non-zero, in which case
       // they are added to the abbreviation declaration, or both be zero to
       // terminate the abbrevation declaration. In this case only one was
if (*MatchAttrIndex == AttrIndex) {
       }
       if (FormValue.extractValue(DebugInfoData, &Offset, &U))
         return FormValue;
     }
     // March Offset along until we get to the attribute we want.
     if (auto FixedSize = Spec.getByteSize(U))
       Offset += *FixedSize;
     else
-      DWARFFormValue::skipValue(Spec.Form, DebugInfoData, &Offset, &U);
+      DWARFFormValue::skipValue(Spec.Form, DebugInfoData, &Offset,
+                                U.getFormParams());
     ++AttrIndex;
   }
   return None;
 }
 
 size_t DWARFAbbreviationDeclaration::FixedSizeInfo::getByteSize(
     const DWARFUnit &U) const {
   size_t ByteSize = NumBytes;
   if (NumAddrs)
     ByteSize += NumAddrs * U.getAddressByteSize();
   if (NumRefAddrs)
     ByteSize += NumRefAddrs * U.getRefAddrByteSize();
   if (NumDwarfOffsets)
     ByteSize += NumDwarfOffsets * U.getDwarfOffsetByteSize();
   return ByteSize;
 }
 
 Optional<int64_t> DWARFAbbreviationDeclaration::AttributeSpec::getByteSize(
     const DWARFUnit &U) const {
   if (isImplicitConst())
     return 0;
   if (ByteSizeOrValue)
     return ByteSizeOrValue;
   Optional<int64_t> S;
-  auto FixedByteSize = DWARFFormValue::getFixedByteSize(Form, &U);
+  auto FixedByteSize =
+      DWARFFormValue::getFixedByteSize(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/DWARFDebugInfoEntry.cpp

bool DWARFDebugInfoEntry::extractFast(const DWARFUnit &U, uint32_t *OffsetPtr,
 
   // Skip all data in the .debug_info for the attributes
   for (const auto &AttrSpec : AbbrevDecl->attributes()) {
     // Check if this attribute has a fixed byte size.
     if (auto FixedSize = AttrSpec.getByteSize(U)) {
       // Attribute byte size if fixed, just add the size to the offset.
       *OffsetPtr += *FixedSize;
     } else if (!DWARFFormValue::skipValue(AttrSpec.Form, DebugInfoData,
-                                          OffsetPtr, &U)) {
+                                          OffsetPtr, U.getFormParams())) {
       // We failed to skip this attribute's value, restore the original offset
       // and return the failure status.
       *OffsetPtr = Offset;
       return false;
     }
   }
   return true;
 }

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

 
 using ContentDescriptors = SmallVector<ContentDescriptor, 4>;
 
 } // end anonmyous namespace
 
 DWARFDebugLine::Prologue::Prologue() { clear(); }
 
 void DWARFDebugLine::Prologue::clear() {
-  TotalLength = Version = PrologueLength = 0;
-  AddressSize = SegSelectorSize = 0;
+  TotalLength = PrologueLength = 0;
+  SegSelectorSize = 0;
   MinInstLength = MaxOpsPerInst = DefaultIsStmt = LineBase = LineRange = 0;
   OpcodeBase = 0;
-  IsDWARF64 = false;
+  FormParams = DWARFFormParams({0, 0, DWARF32});
   StandardOpcodeLengths.clear();
   IncludeDirectories.clear();
   FileNames.clear();
 }
 
 void DWARFDebugLine::Prologue::dump(raw_ostream &OS) const {
   OS << "Line table prologue:\n"
      << format("    total_length: 0x%8.8" PRIx64 "\n", TotalLength)
-     << format("         version: %u\n", Version)
-     << format(Version >= 5 ? "    address_size: %u\n" : "", AddressSize)
-     << format(Version >= 5 ? " seg_select_size: %u\n" : "", SegSelectorSize)
-     << format(" prologue_length: 0x%8.8" PRIx64 "\n", PrologueLength)
+     << format("         version: %u\n", getVersion());
+  if (getVersion() >= 5)
+    OS << format("    address_size: %u\n", getAddressSize())
+       << format(" seg_select_size: %u\n", SegSelectorSize);
+  OS << format(" prologue_length: 0x%8.8" PRIx64 "\n", PrologueLength)
      << format(" min_inst_length: %u\n", MinInstLength)
-     << format(Version >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
+     << format(getVersion() >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
      << format(" default_is_stmt: %u\n", DefaultIsStmt)
      << format("       line_base: %i\n", LineBase)
      << format("      line_range: %u\n", LineRange)
      << format("     opcode_base: %u\n", OpcodeBase);
 
   for (uint32_t I = 0; I != StandardOpcodeLengths.size(); ++I)
     OS << format("standard_opcode_lengths[%s] = %u\n",
                  LNStandardString(I + 1).data(), StandardOpcodeLengths[I]);
for (int I = 0; I != FormatCount; ++I) {
     Descriptors.push_back(Descriptor);
   }
   return HasPath ? Descriptors : ContentDescriptors();
 }
 
 static bool
 parseV5DirFileTables(DataExtractor DebugLineData, uint32_t *OffsetPtr,
                      uint64_t EndPrologueOffset,
+                     const DWARFFormParams &FormParams,
                      std::vector<StringRef> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   // Get the directory entry description.
   ContentDescriptors DirDescriptors =
     parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset);
   if (DirDescriptors.empty())
     return false;
 
   // Get the directory entries, according to the format described above.
   int DirEntryCount = DebugLineData.getU8(OffsetPtr);
   for (int I = 0; I != DirEntryCount; ++I) {
     if (*OffsetPtr >= EndPrologueOffset)
       return false;
     for (auto Descriptor : DirDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
       switch (Descriptor.Type) {
       case DW_LNCT_path:
         if (!Value.extractValue(DebugLineData, OffsetPtr, nullptr))
           return false;
         IncludeDirectories.push_back(Value.getAsCString().getValue());
         break;
       default:
-        if (!Value.skipValue(DebugLineData, OffsetPtr, nullptr))
+        if (!Value.skipValue(DebugLineData, OffsetPtr, FormParams))
           return false;
       }
     }
   }
 
   // Get the file entry description.
   ContentDescriptors FileDescriptors =
     parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset);

 
 bool DWARFDebugLine::Prologue::parse(DataExtractor DebugLineData,
                                      uint32_t *OffsetPtr) {
   const uint64_t PrologueOffset = *OffsetPtr;
 
   clear();
   TotalLength = DebugLineData.getU32(OffsetPtr);
   if (TotalLength == UINT32_MAX) {
-    IsDWARF64 = true;
+    FormParams.Format = dwarf::DWARF64;
     TotalLength = DebugLineData.getU64(OffsetPtr);
-  } else if (TotalLength > 0xffffff00) {
+  } else if (TotalLength >= 0xffffff00) {
     return false;
   }
-  Version = DebugLineData.getU16(OffsetPtr);
-  if (Version < 2)
+  FormParams.Version = DebugLineData.getU16(OffsetPtr);
+  if (getVersion() < 2)
     return false;
 
-  if (Version >= 5) {
-    AddressSize = DebugLineData.getU8(OffsetPtr);
+  if (getVersion() >= 5) {
+    FormParams.AddrSize = DebugLineData.getU8(OffsetPtr);
+    assert(getAddressSize() == DebugLineData.getAddressSize() &&
+           "Line table header and data extractor disagree");
     SegSelectorSize = DebugLineData.getU8(OffsetPtr);
   }
 
   PrologueLength = DebugLineData.getUnsigned(OffsetPtr, sizeofPrologueLength());
   const uint64_t EndPrologueOffset = PrologueLength + *OffsetPtr;
   MinInstLength = DebugLineData.getU8(OffsetPtr);
-  if (Version >= 4)
+  if (getVersion() >= 4)
     MaxOpsPerInst = DebugLineData.getU8(OffsetPtr);
   DefaultIsStmt = DebugLineData.getU8(OffsetPtr);
   LineBase = DebugLineData.getU8(OffsetPtr);
   LineRange = DebugLineData.getU8(OffsetPtr);
   OpcodeBase = DebugLineData.getU8(OffsetPtr);
 
   StandardOpcodeLengths.reserve(OpcodeBase - 1);
   for (uint32_t I = 1; I < OpcodeBase; ++I) {
     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
     StandardOpcodeLengths.push_back(OpLen);
   }
 
-  if (Version >= 5) {
+  if (getVersion() >= 5) {
     if (!parseV5DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
-                              IncludeDirectories, FileNames)) {
+                              getFormParams(), IncludeDirectories, FileNames)) {
       fprintf(stderr,
               "warning: parsing line table prologue at 0x%8.8" PRIx64
               " found an invalid directory or file table description at"
               " 0x%8.8" PRIx64 "\n", PrologueOffset, (uint64_t)*OffsetPtr);
       return false;
     }
   } else
     parseV2DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,

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

static const DWARFFormValue::FormClass DWARF4FormClasses[] = {
     DWARFFormValue::FC_Reference,     // 0x14 DW_FORM_ref8
     DWARFFormValue::FC_Reference,     // 0x15 DW_FORM_ref_udata
     DWARFFormValue::FC_Indirect,      // 0x16 DW_FORM_indirect
     DWARFFormValue::FC_SectionOffset, // 0x17 DW_FORM_sec_offset
     DWARFFormValue::FC_Exprloc,       // 0x18 DW_FORM_exprloc
     DWARFFormValue::FC_Flag,          // 0x19 DW_FORM_flag_present
 };
 
-namespace {
-
-/// A helper class that can be used in DWARFFormValue.cpp functions that need
-/// to know the byte size of DW_FORM values that vary in size depending on the
-/// DWARF version, address byte size, or DWARF32 or DWARF64.
-class FormSizeHelper {
-  uint16_t Version;
-  uint8_t AddrSize;
-  llvm::dwarf::DwarfFormat Format;
-
-public:
-  FormSizeHelper(uint16_t V, uint8_t A, llvm::dwarf::DwarfFormat F)
-      : Version(V), AddrSize(A), Format(F) {}
-
-  uint8_t getAddressByteSize() const { return AddrSize; }
-
-  uint8_t getRefAddrByteSize() const {
-    if (Version == 2)
-      return AddrSize;
-    return getDwarfOffsetByteSize();
-  }
-
-  uint8_t getDwarfOffsetByteSize() const {
-    switch (Format) {
-    case dwarf::DwarfFormat::DWARF32:
-      return 4;
-    case dwarf::DwarfFormat::DWARF64:
-      return 8;
-    }
-    llvm_unreachable("Invalid Format value");
-  }
-};
-
-} // end anonymous namespace
-
-template <class T>
-static Optional<uint8_t> getFixedByteSize(dwarf::Form Form, const T *U) {
+Optional<uint8_t>
+DWARFFormValue::getFixedByteSize(dwarf::Form Form,
+                                 const DWARFFormParams &Params) {
   switch (Form) {
   case DW_FORM_addr:
-    if (U)
-      return U->getAddressByteSize();
-    return None;
+    assert(Params.Version && Params.AddrSize && "Invalid Params for form");
+    return Params.AddrSize;
 
   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 (U)
-      return U->getRefAddrByteSize();
-    return None;
+    assert(Params.Version && Params.AddrSize && "Invalid Params for form");
+    return Params.getRefAddrByteSize();
 
   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_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 (U)
-      return U->getDwarfOffsetByteSize();
-    return None;
+    assert(Params.Version && Params.AddrSize && "Invalid Params for form");
+    return Params.getDwarfOffsetByteSize();
 
   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:
     llvm_unreachable("Handle this form in this switch statement");
   }
   return None;
 }
 
-template <class T>
-static bool skipFormValue(dwarf::Form Form, const DataExtractor &DebugInfoData,
-                          uint32_t *OffsetPtr, const T *U) {
+bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
+                               uint32_t *OffsetPtr,
+                               const DWARFFormParams &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_addrx2:
     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 = ::getFixedByteSize(Form, U)) {
+      if (Optional<uint8_t> FixedSize =
+              DWARFFormValue::getFixedByteSize(Form, Params)) {
         *OffsetPtr += *FixedSize;
         return true;
       }
       return false;
 
     // signed or unsigned LEB 128 values.
     case DW_FORM_sdata:
       DebugInfoData.getSLEB128(OffsetPtr);
do {
 
     default:
       return false;
     }
   } while (Indirect);
   return true;
 }
 
-Optional<uint8_t> DWARFFormValue::getFixedByteSize(dwarf::Form Form,
-                                                   const DWARFUnit *U) {
-  return ::getFixedByteSize(Form, U);
-}
-
-Optional<uint8_t>
-DWARFFormValue::getFixedByteSize(dwarf::Form Form, uint16_t Version,
-                                 uint8_t AddrSize,
-                                 llvm::dwarf::DwarfFormat Format) {
-  FormSizeHelper FSH(Version, AddrSize, Format);
-  return ::getFixedByteSize(Form, &FSH);
-}
-
 bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   // First, check DWARF4 form classes.
   if (Form < makeArrayRef(DWARF4FormClasses).size() &&
       DWARF4FormClasses[Form] == FC)
     return true;
   // Check more forms from DWARF4 and DWARF5 proposals.
   switch (Form) {
   case DW_FORM_ref_sig8:
if (!Str.empty()) {
       Value.data = reinterpret_cast<const uint8_t *>(Str.data());
       *OffsetPtr += Value.uval;
     }
   }
 
   return true;
 }
 
-bool DWARFFormValue::skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
-                               const DWARFUnit *U) const {
-  return DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U);
-}
-
-bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
-                               uint32_t *OffsetPtr, const DWARFUnit *U) {
-  return skipFormValue(Form, DebugInfoData, OffsetPtr, U);
-}
-
-bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
-                               uint32_t *OffsetPtr, uint16_t Version,
-                               uint8_t AddrSize,
-                               llvm::dwarf::DwarfFormat Format) {
-  FormSizeHelper FSH(Version, AddrSize, Format);
-  return skipFormValue(Form, DebugInfoData, OffsetPtr, &FSH);
-}
-
 void DWARFFormValue::dump(raw_ostream &OS) const {
   uint64_t UValue = Value.uval;
   bool CURelativeOffset = false;
 
   switch (Form) {
   case DW_FORM_addr:
     OS << format("0x%016" PRIx64, UValue);
     break;

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

: Context(DC), InfoSection(Section), Abbrev(DA), RangeSection(RS),
       UnitSection(UnitSection), IndexEntry(IndexEntry) {
   clear();
 }
 
 DWARFUnit::~DWARFUnit() = default;
 
 bool DWARFUnit::getAddrOffsetSectionItem(uint32_t Index,
                                                 uint64_t &Result) const {
-  uint32_t Offset = AddrOffsetSectionBase + Index * AddrSize;
-  if (AddrOffsetSection->Data.size() < Offset + AddrSize)
+  uint32_t Offset = AddrOffsetSectionBase + Index * getAddressByteSize();
+  if (AddrOffsetSection->Data.size() < Offset + getAddressByteSize())
     return false;
-  DataExtractor DA(AddrOffsetSection->Data, isLittleEndian, AddrSize);
-  Result = getRelocatedValue(DA, AddrSize, &Offset, &AddrOffsetSection->Relocs);
+  DataExtractor DA(AddrOffsetSection->Data, isLittleEndian,
+                   getAddressByteSize());
+  Result = getRelocatedValue(DA, getAddressByteSize(), &Offset,
+                             &AddrOffsetSection->Relocs);
   return true;
 }
 
 bool DWARFUnit::getStringOffsetSectionItem(uint32_t Index,
                                            uint64_t &Result) const {
   unsigned ItemSize = getFormat() == DWARF64 ? 8 : 4;
   uint32_t Offset = StringOffsetSectionBase + Index * ItemSize;
   if (StringOffsetSection.Data.size() < Offset + ItemSize)
uint64_t DWARFUnit::getStringOffsetSectionRelocation(uint32_t Index) const {
   RelocAddrMap::const_iterator AI = getStringOffsetsRelocMap().find(ByteOffset);
   if (AI != getStringOffsetsRelocMap().end())
     return AI->second.Value;
   return 0;
 }
 
 bool DWARFUnit::extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) {
   Length = debug_info.getU32(offset_ptr);
-  Version = debug_info.getU16(offset_ptr);
+  // FIXME: Support DWARF64.
+  FormParams.Format = DWARF32;
+  FormParams.Version = debug_info.getU16(offset_ptr);
   uint64_t AbbrOffset;
-  if (Version >= 5) {
+  if (FormParams.Version >= 5) {
     UnitType = debug_info.getU8(offset_ptr);
-    AddrSize = debug_info.getU8(offset_ptr);
+    FormParams.AddrSize = debug_info.getU8(offset_ptr);
     AbbrOffset = debug_info.getU32(offset_ptr);
   } else {
     AbbrOffset = debug_info.getU32(offset_ptr);
-    AddrSize = debug_info.getU8(offset_ptr);
+    FormParams.AddrSize = debug_info.getU8(offset_ptr);
   }
   if (IndexEntry) {
     if (AbbrOffset)
       return false;
     auto *UnitContrib = IndexEntry->getOffset();
     if (!UnitContrib || UnitContrib->Length != (Length + 4))
       return false;
     auto *AbbrEntry = IndexEntry->getOffset(DW_SECT_ABBREV);
     if (!AbbrEntry)
       return false;
     AbbrOffset = AbbrEntry->Offset;
   }
 
   bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1);
-  bool VersionOK = DWARFContext::isSupportedVersion(Version);
-  bool AddrSizeOK = AddrSize == 4 || AddrSize == 8;
+  bool VersionOK = DWARFContext::isSupportedVersion(getVersion());
+  bool AddrSizeOK = getAddressByteSize() == 4 || getAddressByteSize() == 8;
 
   if (!LengthOK || !VersionOK || !AddrSizeOK)
     return false;
 
   // Keep track of the highest DWARF version we encounter across all units.
-  Context.setMaxVersionIfGreater(Version);
+  Context.setMaxVersionIfGreater(getVersion());
 
   Abbrevs = Abbrev->getAbbreviationDeclarationSet(AbbrOffset);
   return Abbrevs != nullptr;
 }
 
 bool DWARFUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) {
   clear();
 
bool DWARFUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) {
 
   return false;
 }
 
 bool DWARFUnit::extractRangeList(uint32_t RangeListOffset,
                                         DWARFDebugRangeList &RangeList) const {
   // Require that compile unit is extracted.
   assert(!DieArray.empty());
-  DataExtractor RangesData(RangeSection->Data, isLittleEndian, AddrSize);
+  DataExtractor RangesData(RangeSection->Data, isLittleEndian,
+                           getAddressByteSize());
   uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
   return RangeList.extract(RangesData, &ActualRangeListOffset,
                            RangeSection->Relocs);
 }
 
 void DWARFUnit::clear() {
   Offset = 0;
   Length = 0;
-  Version = 0;
   Abbrevs = nullptr;
-  AddrSize = 0;
+  FormParams = DWARFFormParams({0, 0, DWARF32});
   BaseAddr = 0;
   RangeSectionBase = 0;
   AddrOffsetSectionBase = 0;
   clearDIEs(false);
   DWO.reset();
 }
 
 const char *DWARFUnit::getCompilationDir() {

llvm/trunk/tools/dsymutil/DwarfLinker.cpp

 /// by \p Abbrev.
 /// \return [StartOffset, EndOffset) as a pair.
 static std::pair<uint32_t, uint32_t>
 getAttributeOffsets(const DWARFAbbreviationDeclaration *Abbrev, unsigned Idx,
                     unsigned Offset, const DWARFUnit &Unit) {
   DataExtractor Data = Unit.getDebugInfoExtractor();
 
   for (unsigned i = 0; i < Idx; ++i)
-    DWARFFormValue::skipValue(Abbrev->getFormByIndex(i), Data, &Offset, &Unit);
+    DWARFFormValue::skipValue(Abbrev->getFormByIndex(i), Data, &Offset,
+                              Unit.getFormParams());
 
   uint32_t End = Offset;
-  DWARFFormValue::skipValue(Abbrev->getFormByIndex(Idx), Data, &End, &Unit);
+  DWARFFormValue::skipValue(Abbrev->getFormByIndex(Idx), Data, &End,
+                            Unit.getFormParams());
 
   return std::make_pair(Offset, End);
 }
 
 /// \brief Check if a variable describing DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DwarfLinker::shouldKeepVariableDIE(RelocationManager &RelocMgr,
                                             const DWARFDie &DIE,
void DwarfLinker::keepDIEAndDependencies(RelocationManager &RelocMgr,
   const auto *Abbrev = Die.getAbbreviationDeclarationPtr();
   uint32_t Offset = Die.getOffset() + getULEB128Size(Abbrev->getCode());
 
   // Mark all DIEs referenced through atttributes as kept.
   for (const auto &AttrSpec : Abbrev->attributes()) {
     DWARFFormValue Val(AttrSpec.Form);
 
     if (!Val.isFormClass(DWARFFormValue::FC_Reference)) {
-      DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset, &Unit);
+      DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
+                                Unit.getFormParams());
       continue;
     }
 
     Val.extractValue(Data, &Offset, &Unit);
     CompileUnit *ReferencedCU;
     if (auto RefDIE =
             resolveDIEReference(*this, Units, Val, Unit, Die, ReferencedCU)) {
       uint32_t RefIdx = ReferencedCU->getOrigUnit().getDIEIndex(RefDIE);
if (Abbrev->getTag() == dwarf::DW_TAG_subprogram) {
     if (!Info.InDebugMap)
       Flags |= TF_SkipPC;
   }
 
   bool Copied = false;
   for (const auto &AttrSpec : Abbrev->attributes()) {
     if (shouldSkipAttribute(AttrSpec, Die->getTag(), Info.InDebugMap,
                             Flags & TF_SkipPC, Flags & TF_InFunctionScope)) {
-      DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset, &U);
+      DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
+                                U.getFormParams());
       // FIXME: dsymutil-classic keeps the old abbreviation around
       // even if it's not used. We can remove this (and the copyAbbrev
       // helper) as soon as bit-for-bit compatibility is not a goal anymore.
       if (!Copied) {
         copyAbbrev(*InputDIE.getAbbreviationDeclarationPtr(), Unit.hasODR());
         Copied = true;
       }
       continue;
void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
   }
 
   // Finished extracting, now emit the line tables.
   uint32_t PrologueEnd = *StmtList + 10 + LineTable.Prologue.PrologueLength;
   // FIXME: LLVM hardcodes it's prologue values. We just copy the
   // prologue over and that works because we act as both producer and
   // consumer. It would be nicer to have a real configurable line
   // table emitter.
-  if (LineTable.Prologue.Version != 2 ||
+  if (LineTable.Prologue.getVersion() != 2 ||
       LineTable.Prologue.DefaultIsStmt != DWARF2_LINE_DEFAULT_IS_STMT ||
       LineTable.Prologue.OpcodeBase > 13)
     reportWarning("line table parameters mismatch. Cannot emit.");
   else {
     MCDwarfLineTableParams Params;
     Params.DWARF2LineOpcodeBase = LineTable.Prologue.OpcodeBase;
     Params.DWARF2LineBase = LineTable.Prologue.LineBase;
     Params.DWARF2LineRange = LineTable.Prologue.LineRange;

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

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

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

 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.
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 4, DWARF32);
-  AddrSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 4, DWARF32);
+  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.
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 8, DWARF32);
-  AddrSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 2, 8, DWARF32);
+  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.
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 3, 4, DWARF32);
+  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);
 
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 4, 4, DWARF32);
+  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);
 
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 5, 4, DWARF32);
+  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.
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 3, 8, DWARF64);
+  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);
 
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 4, 8, DWARF64);
+  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);
 
-  RefSize = DWARFFormValue::getFixedByteSize(DW_FORM_ref_addr, 5, 8, DWARF64);
+  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);
 }