[DWARF] Support DWARF64 in DWARFDebugArangeSet.

[ikudrin]

Summary

This allows parsing Address Range Tables in 64-bit DWARF format.

[dblaikie]

Looks good - thanks!

[ikudrin]

• Updated as the parent patch is changed;
• Added more tests.

[dblaikie]

llvm/test/DebugInfo/X86/dwarfdump-debug-aranges-error-cases.s

71–72 ↗

(On Diff #235422)

Not sure if this needs its own test case - since it's the same error/code path for both 32 and 64 bit lengths. (& having only one test for length overrun would enable all the tests to be done in one object file/run, rather than separate RUN lines for each one (some systems, like Windows, have significant per-process overhead so it's nice to keep the total number of separate command invocations down if practical/convenient))

llvm/test/DebugInfo/X86/dwarfdump-debug-aranges.s

81

Similar feedback given on other cases - this is probably overcomplicated (given it already has the magic number 7 and 8 - so maybe hardcoding the exact value, rather than this formula, would be simpler - and include a comment about what this achieves)

[ikudrin]

• Hardcode paddings.
• Move some tests to the gtest-based suite.

[ikudrin]

llvm/test/DebugInfo/X86/dwarfdump-debug-aranges-error-cases.s

71–72 ↗

(On Diff #235422)

This checks that we handle the difference in the length of the initial length field in both formats appropriately. Running additional tests is not a problem anymore, as the tests are moved into a gtest-based suite.

As for continuing processing the table after an error, that requires its own patch, where it should be carefully considered, which errors are recoverable. It might be sophisticated, and I am a bit reluctant to do that without a good sample.

[ikudrin]

• Simplify a bit by using an extracted function dwarf::getDwarfOffsetByteSize().

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h

 
 class raw_ostream;
 
 class DWARFDebugArangeSet {
 public:
   struct Header {
     /// The total length of the entries for that set, not including the length
     /// field itself.
-    uint32_t Length;
+    uint64_t Length;
     /// The offset from the beginning of the .debug_info section of the
     /// compilation unit entry referenced by the table.
-    uint32_t CuOffset;
+    uint64_t CuOffset;
     /// The DWARF version number.
     uint16_t Version;
     /// The size in bytes of an address on the target architecture. For segmented
     /// addressing, this is the size of the offset portion of the address.
     uint8_t AddrSize;
     /// The size in bytes of a segment descriptor on the target architecture.
     /// If the target system uses a flat address space, this value is 0.
     uint8_t SegSize;

 
 public:
   DWARFDebugArangeSet() { clear(); }
 
   void clear();
   Error extract(DataExtractor data, uint64_t *offset_ptr);
   void dump(raw_ostream &OS) const;
 
-  uint32_t getCompileUnitDIEOffset() const { return HeaderData.CuOffset; }
+  uint64_t getCompileUnitDIEOffset() const { return HeaderData.CuOffset; }
 
   const Header &getHeader() const { return HeaderData; }
 
   desc_iterator_range descriptors() const {
     return desc_iterator_range(ArangeDescriptors.begin(),
                                ArangeDescriptors.end());
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFDEBUGARANGESET_H

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

 //===- DWARFDebugArangeSet.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
+#include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <cstring>
 
void DWARFDebugArangeSet::clear() {
   ArangeDescriptors.clear();
 }
 
 Error DWARFDebugArangeSet::extract(DataExtractor data, uint64_t *offset_ptr) {
   assert(data.isValidOffset(*offset_ptr));
   ArangeDescriptors.clear();
   Offset = *offset_ptr;
 
-  // 7.20 Address Range Table
-  //
+  // 7.21 Address Range Table (extract)
   // Each set of entries in the table of address ranges contained in
-  // the .debug_aranges section begins with a header consisting of: a
-  // 4-byte length containing the length of the set of entries for this
-  // compilation unit, not including the length field itself; a 2-byte
-  // version identifier containing the value 2 for DWARF Version 2; a
-  // 4-byte offset into the.debug_infosection; a 1-byte unsigned integer
-  // containing the size in bytes of an address (or the offset portion of
-  // an address for segmented addressing) on the target system; and a
-  // 1-byte unsigned integer containing the size in bytes of a segment
-  // descriptor on the target system. This header is followed by a series
-  // of tuples. Each tuple consists of an address and a length, each in
-  // the size appropriate for an address on the target architecture.
+  // the .debug_aranges section begins with a header containing:
+  // 1. unit_length (initial length)
+  //    A 4-byte (32-bit DWARF) or 12-byte (64-bit DWARF) length containing
+  //    the length of the set of entries for this compilation unit,
+  //    not including the length field itself.
+  // 2. version (uhalf)
+  //    The value in this field is 2.
+  // 3. debug_info_offset (section offset)
+  //    A 4-byte (32-bit DWARF) or 8-byte (64-bit DWARF) offset into the
+  //    .debug_info section of the compilation unit header.
+  // 4. address_size (ubyte)
+  // 5. segment_selector_size (ubyte)
+  // This header is followed by a series of tuples. Each tuple consists of
+  // a segment, an address and a length. The segment selector size is given by
+  // the segment_selector_size field of the header; the address and length
+  // size are each given by the address_size field of the header. Each set of
+  // tuples is terminated by a 0 for the segment, a 0 for the address and 0
+  // for the length. If the segment_selector_size field in the header is zero,
+  // the segment selectors are omitted from all tuples, including
+  // the terminating tuple.
+
+  dwarf::DwarfFormat format = dwarf::DWARF32;
   HeaderData.Length = data.getU32(offset_ptr);
+  if (HeaderData.Length == dwarf::DW_LENGTH_DWARF64) {
+    HeaderData.Length = data.getU64(offset_ptr);
+    format = dwarf::DWARF64;
+  } else if (HeaderData.Length >= dwarf::DW_LENGTH_lo_reserved) {
+    return createStringError(
+        errc::invalid_argument,
+        "address range table at offset 0x%" PRIx64
+        " has unsupported reserved unit length of value 0x%8.8" PRIx64,
+        Offset, HeaderData.Length);
+  }
   HeaderData.Version = data.getU16(offset_ptr);
-  HeaderData.CuOffset = data.getU32(offset_ptr);
+  HeaderData.CuOffset =
+      data.getUnsigned(offset_ptr, dwarf::getDwarfOffsetByteSize(format));
   HeaderData.AddrSize = data.getU8(offset_ptr);
   HeaderData.SegSize = data.getU8(offset_ptr);
 
   // Perform basic validation of the header fields.
-  if (!data.isValidOffsetForDataOfSize(Offset, HeaderData.Length + 4))
+  uint64_t full_length =
+      dwarf::getUnitLengthFieldByteSize(format) + HeaderData.Length;
+  if (!data.isValidOffsetForDataOfSize(Offset, full_length))
     return createStringError(errc::invalid_argument,
                              "the length of address range table at offset "
                              "0x%" PRIx64 " exceeds section size",
                              Offset);
   if (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)
     return createStringError(errc::invalid_argument,
                              "address range table at offset 0x%" PRIx64
                              " has unsupported address size: %d "
Error DWARFDebugArangeSet::extract(DataExtractor data, uint64_t *offset_ptr) {
 
   return createStringError(errc::invalid_argument,
                            "address range table at offset 0x%" PRIx64
                            " is not terminated by null entry",
                            Offset);
 }
 
 void DWARFDebugArangeSet::dump(raw_ostream &OS) const {
-  OS << format("Address Range Header: length = 0x%8.8x, version = 0x%4.4x, ",
-               HeaderData.Length, HeaderData.Version)
-     << format("cu_offset = 0x%8.8x, addr_size = 0x%2.2x, seg_size = 0x%2.2x\n",
-               HeaderData.CuOffset, HeaderData.AddrSize, HeaderData.SegSize);
+  OS << "Address Range Header: "
+     << format("length = 0x%8.8" PRIx64 ", ", HeaderData.Length)
+     << format("version = 0x%4.4x, ", HeaderData.Version)
+     << format("cu_offset = 0x%8.8" PRIx64 ", ", HeaderData.CuOffset)
+     << format("addr_size = 0x%2.2x, ", HeaderData.AddrSize)
+     << format("seg_size = 0x%2.2x\n", HeaderData.SegSize);
 
   for (const auto &Desc : ArangeDescriptors) {
     Desc.dump(OS, HeaderData.AddrSize);
     OS << '\n';
   }
 }

llvm/test/DebugInfo/X86/dwarfdump-debug-aranges.s

# CHECK-SAME: seg_size = 0x00
     .space  4                       # Padding
 .L3tuples:
     .quad   0x1122334455667788      # Address
     .quad   0x0102030405060708      # Length
 # CHECK-NEXT: [0x1122334455667788,  0x122436485a6c7e90)
     .quad   0, 0                    # Termination tuple
 # CHECK-NOT: [0x
 .L3end:
+
+## Case 4: Check that 64-bit DWARF format is supported.
+    .long 0xffffffff                # DWARF64 mark
+    .quad   .L4end - .L4version     # Length
+# CHECK: Address Range Header: length = 0x0000001c,
+.L4version:
+    .short  2                       # Version
+    .quad   0x1234567899aabbcc      # Debug Info Offset
+    .byte   4                       # Address Size
+    .byte   0                       # Segment Selector Size
+# CHECK-SAME: version = 0x0002,
+# CHECK-SAME: cu_offset = 0x1234567899aabbcc,
+# CHECK-SAME: addr_size = 0x04,
+# CHECK-SAME: seg_size = 0x00
+                                    # No padding
+.L4tuples:
+    .long   0, 1                    # Address and length
+# CHECK-NEXT: [0x00000000,  0x00000001)
+    .long   0, 0                    # Termination tuple
+# CHECK-NOT: [0x
+.L4end:

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

static const char DebugArangesSecRaw[] =
       "\x00\x00\x00\x00" // Padding
       "\x00\x00\x00\x00" // Termination tuple
       "\x00\x00\x00\x00";
   ExpectExtractError(
       DebugArangesSecRaw,
       "the length of address range table at offset 0x0 exceeds section size");
 }
 
+TEST(DWARFDebugArangeSet, LengthExceedsSectionSizeDWARF64) {
+  static const char DebugArangesSecRaw[] =
+      "\xff\xff\xff\xff"                 // DWARF64 mark
+      "\x15\x00\x00\x00\x00\x00\x00\x00" // The length exceeds the section
+                                         // boundaries
+      "\x02\x00"                         // Version
+      "\x00\x00\x00\x00\x00\x00\x00\x00" // Debug Info Offset
+      "\x04"                             // Address Size
+      "\x00"                             // Segment Selector Size
+                                         // No padding
+      "\x00\x00\x00\x00"                 // Termination tuple
+      "\x00\x00\x00\x00";
+  ExpectExtractError(
+      DebugArangesSecRaw,
+      "the length of address range table at offset 0x0 exceeds section size");
+}
+
 TEST(DWARFDebugArangeSet, UnsupportedAddressSize) {
   static const char DebugArangesSecRaw[] =
       "\x0c\x00\x00\x00"  // Length
       "\x02\x00"          // Version
       "\x00\x00\x00\x00"  // Debug Info Offset
       "\x02"              // Address Size (not supported)
       "\x00"              // Segment Selector Size
                           // No padding
static const char DebugArangesSecRaw[] =
       "\x00\x00\x00\x00" // Entry: Address
       "\x01\x00\x00\x00" //        Length
       ;                  // No termination tuple
   ExpectExtractError(
       DebugArangesSecRaw,
       "address range table at offset 0x0 is not terminated by null entry");
 }
 
+TEST(DWARFDebugArangeSet, ReservedUnitLength) {
+  static const char DebugArangesSecRaw[] =
+      "\xf0\xff\xff\xff"; // Reserved unit length value
+  ExpectExtractError(
+      DebugArangesSecRaw,
+      "address range table at offset 0x0 has unsupported reserved unit length "
+      "of value 0xfffffff0");
+}
+
 } // end anonymous namespace