Clean up DWARFFormValue by reducing duplicated code and removing DWARFFormValue::getFixedFormSizes()

In preparation for a follow on patch that improves DWARF parsing speed, clean up DWARFFormValue so that we have can get the fixed byte size of a form value given a DWARFUnit or given the version, address byte size and dwarf32/64.

This patch cleans up code so that everyone is using one of the new DWARFFormValue functions:

static Optional<uint8_t> DWARFFormValue::getFixedByteSize(dwarf::Form Form, const DWARFUnit *U = nullptr);
static Optional<uint8_t> DWARFFormValue::getFixedByteSize(dwarf::Form Form, uint16_t Version, uint8_t AddrSize, bool Dwarf32);

This patch changes DWARFFormValue::skipValue() to rely on the output of DWARFFormValue::getFixedByteSize(...) instead of duplicating the code in each function. This will reduce the number of changes we need to make to DWARF to fewer places in DWARFFormValue when we add support for new form.

This patch also starts to support DWARF64 so that we can get correct byte sizes for forms that vary according the DWARF 32/64.

To reduce the code duplication a new FormSizeHelper pure virtual class was created that can be created as a FormSizeHelperDWARFUnit when you have a DWARFUnit, or FormSizeHelperManual where you manually specify the DWARF version, address byte size and DWARF32/DWARF64. There is now a single implementation of a function that gets the fixed byte size (instead of two where one took a DWARFUnit and one took the DWARF version, address byte size and DWARFFormat enum) and one function to skip the form values.

https://reviews.llvm.org/D26526

llvm-svn: 286597

Author: Greg Clayton

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

@@ -81,17 +81,79 @@ class DWARFFormValue {
   Optional<uint64_t> getAsAddress() const;
   Optional<uint64_t> getAsSectionOffset() const;
   Optional<ArrayRef<uint8_t>> getAsBlock() 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.
+  ///
+  /// \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.
+  /// \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 debug_info_data at offset specified by \p offset_ptr.
+  ///
+  /// Skips the bytes for this form in the debug info and updates the offset.
+  ///
+  /// \param debug_info_data the .debug_info data to use to skip the value.
+  /// \param offset_ptr 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 debug_info_data, uint32_t *offset_ptr,
                  const DWARFUnit *U) const;
+  /// Skip a form in \p debug_info_data at offset specified by \p offset_ptr.
+  ///
+  /// Skips the bytes for this form in the debug info and updates the offset.
+  ///
+  /// \param form the DW_FORM enumeration that indicates the form to skip.
+  /// \param debug_info_data the .debug_info data to use to skip the value.
+  /// \param offset_ptr 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.
   static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
-                        uint32_t *offset_ptr, const DWARFUnit *u);
+                        uint32_t *offset_ptr, const DWARFUnit *U);
+  /// Skip a form in \p debug_info_data at offset specified by \p offset_ptr.
+  ///
+  /// Skips the bytes for this form in the debug info and updates the offset.
+  ///
+  /// \param form the DW_FORM enumeration that indicates the form to skip.
+  /// \param debug_info_data the .debug_info data to use to skip the value.
+  /// \param offset_ptr 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.
+  /// \returns true on success, false if the form was not skipped.
   static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
                         uint32_t *offset_ptr, uint16_t Version,
-                        uint8_t AddrSize);
+                        uint8_t AddrSize, llvm::dwarf::DwarfFormat Format);
 
-  static ArrayRef<uint8_t> getFixedFormSizes(uint8_t AddrSize,
-                                             uint16_t Version);
 private:
   void dumpString(raw_ostream &OS) const;
 };

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

@@ -191,13 +191,25 @@ class DWARFUnit {
   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 DWARFAbbreviationDeclarationSet *getAbbreviations() const {
     return Abbrevs;
   }
   uint8_t getAddressByteSize() const { return AddrSize; }
   uint8_t getRefAddrByteSize() const {
-    // FIXME: Support DWARF64.
-    return (Version == 2) ? AddrSize : 4;
+    if (Version == 2)
+      return AddrSize;
+    return getDwarfOffsetByteSize();
+  }
+  uint8_t getDwarfOffsetByteSize() const {
+    switch (getFormat()) {
+    case dwarf::DwarfFormat::DWARF32:
+      return 4;
+    case dwarf::DwarfFormat::DWARF64:
+      return 8;
+    }
   }
   uint64_t getBaseAddress() const { return BaseAddr; }
 

llvm/include/llvm/Support/Dwarf.h

@@ -433,6 +433,9 @@ struct PubIndexEntryDescriptor {
   };
 };
 
+/// Constants that define the DWARF format as 32 or 64 bit.
+enum DwarfFormat { DWARF32, DWARF64 };
+
 } // End of namespace dwarf
 
 } // End of namespace llvm

llvm/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

@@ -202,18 +202,13 @@ bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit *U,
     *OffsetPtr = Offset;
     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()) {
     auto Form = AttrSpec.Form;
 
-    uint8_t FixedFormSize =
-        (Form < FixedFormSizes.size()) ? FixedFormSizes[Form] : 0;
-    if (FixedFormSize)
-      *OffsetPtr += FixedFormSize;
+    if (Optional<uint8_t> FixedSize = DWARFFormValue::getFixedByteSize(Form, U))
+      *OffsetPtr += *FixedSize;
     else if (!DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U)) {
       // Restore the original offset.
       *OffsetPtr = Offset;