[DWARF] Support 64-bit DWARF in .debug_pubnames and alike.

[probinson]

Is there any producer that actually emits a 64-bit pubnames? (i.e., is this really worth bothering with?)

I'd have expected the mismatch between section size and the DWARF unit length to cause some sort of warning, but I see that the old code didn't care about malformed info, so that shouldn't block this patch.

[ikudrin]

I do not have a sample. Right now I am adding DWARF64 to the diagnostic tools to simplify further work on producers.

I have added DWARF64 here just for completeness. The tables are already obsolete in DWARF5, so I do not have plans to improve the parsing too much.

[probinson]

Well... the code is not complicated and is consistent with how other sections are handled. LGTM

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugPubTable.h

public:
 
   /// Each table consists of sets of variable length entries. Each set describes
   /// the names of global objects and functions, or global types, respectively,
   /// whose definitions are represented by debugging information entries owned
   /// by a single compilation unit.
   struct Set {
     /// The total length of the entries for that set, not including the length
     /// field itself.
-    uint32_t Length;
+    uint64_t Length;
 
     /// This number is specific to the name lookup table and is independent of
     /// the DWARF version number.
     uint16_t Version;
 
     /// The offset from the beginning of the .debug_info section of the
     /// compilation unit header referenced by the set.
     uint64_t Offset;
 
     /// The size in bytes of the contents of the .debug_info section generated
     /// to represent that compilation unit.
-    uint32_t Size;
+    uint64_t Size;
 
     std::vector<Entry> Entries;
   };
 
 private:
   std::vector<Set> Sets;
 
   /// gnu styled tables contains additional information.

llvm/lib/DebugInfo/DWARF/DWARFDebugPubTable.cpp

DWARFDebugPubTable::DWARFDebugPubTable(const DWARFObject &Obj,
                                        bool LittleEndian, bool GnuStyle)
     : GnuStyle(GnuStyle) {
   DWARFDataExtractor PubNames(Obj, Sec, LittleEndian, 0);
   uint64_t Offset = 0;
   while (PubNames.isValidOffset(Offset)) {
     Sets.push_back({});
     Set &SetData = Sets.back();
 
+    dwarf::DwarfFormat Format = dwarf::DWARF32;
     SetData.Length = PubNames.getU32(&Offset);
+    if (SetData.Length == dwarf::DW_LENGTH_DWARF64) {
+      Format = dwarf::DWARF64;
+      SetData.Length = PubNames.getU64(&Offset);
+    }
+    const unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(Format);
+
     SetData.Version = PubNames.getU16(&Offset);
-    SetData.Offset = PubNames.getRelocatedValue(4, &Offset);
-    SetData.Size = PubNames.getU32(&Offset);
+    SetData.Offset = PubNames.getRelocatedValue(OffsetSize, &Offset);
+    SetData.Size = PubNames.getUnsigned(&Offset, OffsetSize);
 
     while (Offset < Sec.Data.size()) {
-      uint32_t DieRef = PubNames.getU32(&Offset);
+      uint64_t DieRef = PubNames.getUnsigned(&Offset, OffsetSize);
       if (DieRef == 0)
         break;
       uint8_t IndexEntryValue = GnuStyle ? PubNames.getU8(&Offset) : 0;
       StringRef Name = PubNames.getCStrRef(&Offset);
       SetData.Entries.push_back(
           {DieRef, PubIndexEntryDescriptor(IndexEntryValue), Name});
     }
   }
 }
 
 void DWARFDebugPubTable::dump(raw_ostream &OS) const {
   for (const Set &S : Sets) {
-    OS << "length = " << format("0x%08x", S.Length);
+    OS << "length = " << format("0x%08" PRIx64, S.Length);
     OS << " version = " << format("0x%04x", S.Version);
     OS << " unit_offset = " << format("0x%08" PRIx64, S.Offset);
-    OS << " unit_size = " << format("0x%08x", S.Size) << '\n';
+    OS << " unit_size = " << format("0x%08" PRIx64, S.Size) << '\n';
     OS << (GnuStyle ? "Offset     Linkage  Kind     Name\n"
                     : "Offset     Name\n");
 
     for (const Entry &E : S.Entries) {
       OS << format("0x%8.8" PRIx64 " ", E.SecOffset);
       if (GnuStyle) {
         StringRef EntryLinkage =
             GDBIndexEntryLinkageString(E.Descriptor.Linkage);
         StringRef EntryKind = dwarf::GDBIndexEntryKindString(E.Descriptor.Kind);
         OS << format("%-8s", EntryLinkage.data()) << ' '
            << format("%-8s", EntryKind.data()) << ' ';
       }
       OS << '\"' << E.Name << "\"\n";
     }
   }
 }

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

+# RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
+# RUN:   llvm-dwarfdump -debug-pubnames - | \
+# RUN:   FileCheck %s
+
+# CHECK: .debug_pubnames contents:
+# CHECK-NEXT: length = 0x00000032
+# CHECK-SAME: version = 0x0002
+# CHECK-SAME: unit_offset = 0x1122334455667788
+# CHECK-SAME: unit_size = 0x1100220033004400
+# CHECK-NEXT: Offset     Name
+# CHECK-NEXT: 0xaa01aaaabbbbbbbb "foo"
+# CHECK-NEXT: 0xaa02aaaabbbbbbbb "bar"
+
+    .section .debug_pubnames,"",@progbits
+    .long 0xffffffff            # DWARF64 mark
+    .quad .Lend - .Lversion     # Unit Length
+.Lversion:
+    .short 2                    # Version
+    .quad 0x1122334455667788    # Debug Info Offset
+    .quad 0x1100220033004400    # Debug Info Length
+    .quad 0xaa01aaaabbbbbbbb    # Tuple0: Offset
+    .asciz "foo"                #         Name
+    .quad 0xaa02aaaabbbbbbbb    # Tuple1: Offset
+    .asciz "bar"                #         Name
+    .quad 0                     # Terminator
+.Lend: