[DWARF v5] incorrect length of string offsets tables

[wolfgangp]

Summary

This patch fixes a bug with DWARF v5 string offsets tables found by David Anderson. Currently the length encodes the length of the contribution minus the size of the table header, when the standard demands it to be the contribution length minus the size of the length field. So it's basically off by 4 at the moment, failing to account for the version field and padding in the header.

This patch fixes this in both the reader and producer code.

[JDevlieghere]

Thanks Wolfgang, LGTM!

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

 struct BaseAddress {
   uint64_t Address;
   uint64_t SectionIndex;
 };
 
 /// Represents a unit's contribution to the string offsets table.
 struct StrOffsetsContributionDescriptor {
   uint64_t Base = 0;
+  /// The contribution size not including the header.
   uint64_t Size = 0;
   /// Format and version.
   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}) {}
 

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

 void DwarfFile::emitStringOffsetsTableHeader(MCSection *Section) {
   if (StrPool.empty())
     return;
   Asm->OutStreamer->SwitchSection(Section);
   unsigned EntrySize = 4;
   // FIXME: DWARF64
   // We are emitting the header for a contribution to the string offsets
   // table. The header consists of an entry with the contribution's
-  // size (not including the size of the header), the DWARF version and
+  // size (not including the size of the length field), the DWARF version and
   // 2 bytes of padding.
-  Asm->emitInt32(StrPool.size() * EntrySize);
+  Asm->emitInt32(StrPool.size() * EntrySize + 4);
   Asm->emitInt16(Asm->getDwarfVersion());
   Asm->emitInt16(0);
   // Define the symbol that marks the start of the contribution. It is
   // referenced by most unit headers via DW_AT_str_offsets_base.
   // Split units do not use the attribute.
   if (StringOffsetsStartSym)
     Asm->OutStreamer->EmitLabel(StringOffsetsStartSym);
 }

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

if (Offset > ContributionHeader) {
       return;
     }
     // Report a gap in the table.
     if (Offset < ContributionHeader) {
       OS << format("0x%8.8x: Gap, length = ", Offset);
       OS << (ContributionHeader - Offset) << "\n";
     }
     OS << format("0x%8.8x: ", (uint32_t)ContributionHeader);
-    OS << "Contribution size = " << Contribution->Size
+    // In DWARF v5 the contribution size in the descriptor does not equal
+    // the originally encoded length (it does not contain the length of the
+    // version field and the padding, a total of 4 bytes). Add them back in
+    // for reporting.
+    OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4))
        << ", Format = " << (Format == DWARF32 ? "DWARF32" : "DWARF64")
        << ", Version = " << Version << "\n";
 
     Offset = Contribution->Base;
     unsigned EntrySize = Contribution->getDwarfOffsetByteSize();
     while (Offset - Contribution->Base < Contribution->Size) {
       OS << format("0x%8.8x: ", Offset);
       // FIXME: We can only extract strings if the offset fits in 32 bits.

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

if (!DA.isValidOffsetForDataOfSize(Offset, 16))
     return Optional<StrOffsetsContributionDescriptor>();
 
   if (DA.getU32(&Offset) != 0xffffffff)
     return Optional<StrOffsetsContributionDescriptor>();
 
   uint64_t Size = DA.getU64(&Offset);
   uint8_t Version = DA.getU16(&Offset);
   (void)DA.getU16(&Offset); // padding
-  return StrOffsetsContributionDescriptor(Offset, Size, Version, DWARF64);
+  // The encoded length includes the 2-byte version field and the 2-byte
+  // padding, so we need to subtract them out when we populate the descriptor.
+  return StrOffsetsContributionDescriptor(Offset, Size - 4, Version, DWARF64);
   //return Optional<StrOffsetsContributionDescriptor>(Descriptor);
 }
 
 // Look for a DWARF32-formatted contribution to the string offsets table
 // starting at a given offset and record it in a descriptor.
 static Optional<StrOffsetsContributionDescriptor>
 parseDWARF32StringOffsetsTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
   if (!DA.isValidOffsetForDataOfSize(Offset, 8))
     return Optional<StrOffsetsContributionDescriptor>();
   uint32_t ContributionSize = DA.getU32(&Offset);
   if (ContributionSize >= 0xfffffff0)
     return Optional<StrOffsetsContributionDescriptor>();
   uint8_t Version = DA.getU16(&Offset);
   (void)DA.getU16(&Offset); // padding
-  return StrOffsetsContributionDescriptor(Offset, ContributionSize, Version, DWARF32);
+  // The encoded length includes the 2-byte version field and the 2-byte
+  // padding, so we need to subtract them out when we populate the descriptor.
+  return StrOffsetsContributionDescriptor(Offset, ContributionSize - 4, Version,
+                                          DWARF32);
   //return Optional<StrOffsetsContributionDescriptor>(Descriptor);
 }
 
 Optional<StrOffsetsContributionDescriptor>
 DWARFUnit::determineStringOffsetsTableContribution(DWARFDataExtractor &DA,
                                                    uint64_t Offset) {
   Optional<StrOffsetsContributionDescriptor> Descriptor;
   // Attempt to find a DWARF64 contribution 16 bytes before the base.

llvm/trunk/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-3.s

# Invalid length
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base0:
         .long str_producer
         .long str_CU1
         .long str_CU1_dir
 .debug_str_offsets_segment0_end:
 # CU2's contribution
-        .long .debug_str_offsets_segment1_end-.debug_str_offsets_base1
+        .long .debug_str_offsets_segment1_end-.debug_str_offsets_base1+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base1:
         .long str_producer
         .long str_CU2
         .long str_CU2_dir
 .debug_str_offsets_segment1_end:
 # The TU's contribution
-        .long .debug_str_offsets_segment2_end-.debug_str_offsets_base2
+        .long .debug_str_offsets_segment2_end-.debug_str_offsets_base2+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base2:
         .long str_TU
         .long str_TU_type
 .debug_str_offsets_segment2_end:
 
 # INVALIDCONTRIB:            .debug_str_offsets contents:
 # INVALIDCONTRIB-NOT:        contents:
 # INVALIDCONTRIB:            error: invalid contribution to string offsets table in section .debug_str_offsets.

llvm/trunk/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-4.s

# A compile-unit DIE, which has no attributes.
         .long .debug_str_offsets_base0
 CU1_5_end:
 
 # Every unit contributes to the string_offsets table.
         .section .debug_str_offsets,"",@progbits
 # CU1's contribution
 # The length is not a multiple of 4. Check that we don't read off the
 # end.
-        .long .debug_str_offsets_segment0_end-.debug_str_offsets_base0
+        .long .debug_str_offsets_segment0_end-.debug_str_offsets_base0+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base0:
         .long str_producer
         .long str_CU1
         .byte 0
 .debug_str_offsets_segment0_end:
 
 # INVALIDLENGTH:             .debug_str_offsets contents:
 # INVALIDLENGTH-NOT:         contents:
 # INVALIDLENGTH:             error: invalid contribution to string offsets table in section .debug_str_offsets.

llvm/trunk/test/DebugInfo/X86/dwarfdump-str-offsets-invalid-6.s

CU2_5_version:
         .long .debug_abbrev    # Offset Into Abbrev. Section
 # A compile-unit DIE, which has no attributes.
         .byte 1                # Abbreviation code
         .long .debug_str_offsets_base1
 CU2_5_end:
 
         .section .debug_str_offsets,"",@progbits
 # CU1's contribution
-        .long .debug_str_offsets_segment1_end-.debug_str_offsets_base0
+        .long .debug_str_offsets_segment1_end-.debug_str_offsets_base0+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base0:
         .long str_producer
         .long str_CU1
         .long str_CU1_dir
 .debug_str_offsets_segment0_end:
 # CU2's contribution
 # Overlapping with CU1's contribution
-        .long .debug_str_offsets_segment1_end-.debug_str_offsets_base1
+        .long .debug_str_offsets_segment1_end-.debug_str_offsets_base1+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base1:
         .long str_producer
         .long str_CU2
         .long str_CU2_dir
 .debug_str_offsets_segment1_end:
 
 # OVERLAP:            .debug_str_offsets contents:
 # OVERLAP-NOT:        contents:
 # OVERLAP:            error: overlapping contributions to string offsets table in section .debug_str_offsets.

llvm/trunk/test/DebugInfo/X86/dwarfdump-str-offsets-macho.s

str_Variable1:
         .asciz "MyVar1"
 str_Variable2:
         .asciz "MyVar2"
 str_Variable3:
         .asciz "MyVar3"
 
   .section  __DWARF,__debug_str_offs,regular,debug
 Ldebug_str_offsets:
-        .long Ldebug_str_offsets_segment0_end-Ldebug_str_offsets_base0
+        .long Ldebug_str_offsets_segment0_end-Ldebug_str_offsets_base0+4
         .short 5    # DWARF version
         .short 0    # Padding
 Ldebug_str_offsets_base0:
         .long str_producer
         .long str_CU1
         .long str_CU1_dir
         .long str_Subprogram
         .long str_Variable1
         .long str_Variable2
         .long str_Variable3
 Ldebug_str_offsets_segment0_end:
 # A 4-byte gap.
         .long 0
 # CU2's contribution (DWARF64 format)
         .long 0xffffffff
-        .quad Ldebug_str_offsets_segment1_end-Ldebug_str_offsets_base1
+        .quad Ldebug_str_offsets_segment1_end-Ldebug_str_offsets_base1+4
         .short 5    # DWARF version
         .short 0    # Padding
 Ldebug_str_offsets_base1:
         .quad str_producer
         .quad str_CU2
         .quad str_CU2_dir
 Ldebug_str_offsets_segment1_end:
 # The TU's contribution
-        .long Ldebug_str_offsets_segment2_end-Ldebug_str_offsets_base2
+        .long Ldebug_str_offsets_segment2_end-Ldebug_str_offsets_base2+4
         .short 5    # DWARF version
         .short 0    # Padding
 Ldebug_str_offsets_base2:
         .long str_TU
         .long str_TU_type
 Ldebug_str_offsets_segment2_end:
 
   .section  __DWARF,__debug_abbrev,regular,debug

 # COMMON:      DW_TAG_type_unit
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000000) string = "Type_Unit")
 # COMMON-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000058)
 # COMMON:      DW_TAG_structure_type
 # COMMON-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "MyStruct")
 # 
 # The .debug_str_offsets section
 # COMMON:      .debug_str_offsets contents:
-# COMMON-NEXT: 0x00000000: Contribution size = 28, Format = DWARF32, Version = 5
+# COMMON-NEXT: 0x00000000: Contribution size = 32, Format = DWARF32, Version = 5
 # COMMON-NEXT: 0x00000008: 00000000 "Handmade DWARF producer"
 # COMMON-NEXT: 0x0000000c: 00000018 "Compile_Unit_1"
 # COMMON-NEXT: 0x00000010: 00000027 "/home/test/CU1"
 # COMMON-NEXT: 0x00000014: 00000067 "MyFunc"
 # COMMON-NEXT: 0x00000018: 0000006e "MyVar1"
 # COMMON-NEXT: 0x0000001c: 00000075 "MyVar2"
 # COMMON-NEXT: 0x00000020: 0000007c "MyVar3"
 # COMMON-NEXT: 0x00000024: Gap, length = 4
-# COMMON-NEXT: 0x00000028: Contribution size = 24, Format = DWARF64, Version = 5
+# COMMON-NEXT: 0x00000028: Contribution size = 28, Format = DWARF64, Version = 5
 # COMMON-NEXT: 0x00000038: 00000000 "Handmade DWARF producer"
 # COMMON-NEXT: 0x00000040: 00000036 "Compile_Unit_2"
 # COMMON-NEXT: 0x00000048: 00000045 "/home/test/CU2"
-# COMMON-NEXT: 0x00000050: Contribution size = 8, Format = DWARF32, Version = 5
+# COMMON-NEXT: 0x00000050: Contribution size = 12, Format = DWARF32, Version = 5
 # COMMON-NEXT: 0x00000058: 00000054 "Type_Unit"
 # COMMON-NEXT: 0x0000005c: 0000005e "MyStruct"

llvm/trunk/test/DebugInfo/X86/dwarfdump-str-offsets.s

 str_Variable2:
         .asciz "MyVar2"
 str_Variable3:
         .asciz "MyVar3"
 
 # Every unit contributes to the string_offsets table.
         .section .debug_str_offsets,"",@progbits
 # CU1's contribution
-        .long .debug_str_offsets_segment0_end-.debug_str_offsets_base0
+        .long .debug_str_offsets_segment0_end-.debug_str_offsets_base0+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base0:
         .long str_producer
         .long str_CU1
         .long str_CU1_dir
         .long str_Subprogram
         .long str_Variable1
         .long str_Variable2
         .long str_Variable3
 .debug_str_offsets_segment0_end:
 # A 4-byte gap.
         .long 0
 # CU2's contribution in DWARF64 format
         .long 0xffffffff
-        .quad .debug_str_offsets_segment1_end-.debug_str_offsets_base1
+        .quad .debug_str_offsets_segment1_end-.debug_str_offsets_base1+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base1:
         .quad str_producer
         .quad str_CU2
         .quad str_CU2_dir
 .debug_str_offsets_segment1_end:
 # The TU's contribution
-        .long .debug_str_offsets_segment2_end-.debug_str_offsets_base2
+        .long .debug_str_offsets_segment2_end-.debug_str_offsets_base2+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base2:
         .long str_TU
         .long str_TU_type
 .debug_str_offsets_segment2_end:
 
         .section .debug_str.dwo,"MS",@progbits,1
 dwo_str_CU_5_producer:
         .asciz "Handmade split DWARF producer"
 dwo_str_CU_5_name:
         .asciz "V5_split_compile_unit"
 dwo_str_CU_5_comp_dir:
         .asciz "/home/test/splitCU"
 dwo_str_TU_5:
         .asciz "V5_split_type_unit"
 dwo_str_TU_5_type:
         .asciz "V5_split_Mystruct"
 
         .section .debug_str_offsets.dwo,"",@progbits
 # One contribution only in a .dwo file
-        .long .debug_dwo_str_offsets_segment0_end-.debug_dwo_str_offsets_base0
+        .long .debug_dwo_str_offsets_segment0_end-.debug_dwo_str_offsets_base0+4
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_dwo_str_offsets_base0:
         .long dwo_str_CU_5_producer-.debug_str.dwo
         .long dwo_str_CU_5_name-.debug_str.dwo
         .long dwo_str_CU_5_comp_dir-.debug_str.dwo
         .long dwo_str_TU_5-.debug_str.dwo
         .long dwo_str_TU_5_type-.debug_str.dwo

 # SPLIT:       .debug_types.dwo contents:
 # SPLIT:       DW_TAG_type_unit
 # SPLIT-NEXT:  DW_AT_name [DW_FORM_strx] ( indexed (00000003) string = "V5_split_type_unit")
 # SPLIT:       DW_TAG_structure_type
 # SPLIT-NEXT:  DW_AT_name [DW_FORM_strx] ( indexed (00000004) string = "V5_split_Mystruct")
 # 
 # The .debug_str_offsets section
 # COMMON:      .debug_str_offsets contents:
-# COMMON-NEXT: 0x00000000: Contribution size = 28, Format = DWARF32, Version = 5
+# COMMON-NEXT: 0x00000000: Contribution size = 32, Format = DWARF32, Version = 5
 # COMMON-NEXT: 0x00000008: 00000000 "Handmade DWARF producer"
 # COMMON-NEXT: 0x0000000c: 00000018 "Compile_Unit_1"
 # COMMON-NEXT: 0x00000010: 00000027 "/home/test/CU1"
 # COMMON-NEXT: 0x00000014: 00000067 "MyFunc"
 # COMMON-NEXT: 0x00000018: 0000006e "MyVar1"
 # COMMON-NEXT: 0x0000001c: 00000075 "MyVar2"
 # COMMON-NEXT: 0x00000020: 0000007c "MyVar3"
 # COMMON-NEXT: Gap, length = 4
-# COMMON-NEXT: 0x00000028: Contribution size = 24, Format = DWARF64, Version = 5
+# COMMON-NEXT: 0x00000028: Contribution size = 28, Format = DWARF64, Version = 5
 # COMMON-NEXT: 0x00000038: 00000000 "Handmade DWARF producer"
 # COMMON-NEXT: 0x00000040: 00000036 "Compile_Unit_2"
 # COMMON-NEXT: 0x00000048: 00000045 "/home/test/CU2"
-# COMMON-NEXT: 0x00000050: Contribution size = 8, Format = DWARF32, Version = 5
+# COMMON-NEXT: 0x00000050: Contribution size = 12, Format = DWARF32, Version = 5
 # COMMON-NEXT: 0x00000058: 00000054 "Type_Unit"
 # COMMON-NEXT: 0x0000005c: 0000005e "MyStruct"
 # 
 # SPLIT:       .debug_str_offsets.dwo contents:
-# SPLIT-NEXT:  0x00000000: Contribution size = 20, Format = DWARF32, Version = 5
+# SPLIT-NEXT:  0x00000000: Contribution size = 24, Format = DWARF32, Version = 5
 # SPLIT-NEXT:  0x00000008: 00000000 "Handmade split DWARF producer"
 # SPLIT-NEXT:  0x0000000c: 0000001e "V5_split_compile_unit"
 # SPLIT-NEXT:  0x00000010: 00000034 "/home/test/splitCU"
 # SPLIT-NEXT:  0x00000014: 00000047 "V5_split_type_unit"
 # SPLIT-NEXT:  0x00000018: 0000005a "V5_split_Mystruct"

llvm/trunk/test/DebugInfo/X86/string-offsets-multiple-cus.ll

 ; offsets section.
 ; BOTH:           .debug_str contents:
 ; BOTH-NOT:       contents:
 ; BOTH:           0x[[GLOB2OFF:[0-9a-f]+]]: "glob2"
 ;
 ; Check the .debug_str_offsets section header and make sure the referenced string
 ; has the correct offset.
 ; BOTH:           .debug_str_offsets contents:
-; BOTH-NEXT:      0x00000000: Contribution size = 80, Format = DWARF32, Version = 5
+; BOTH-NEXT:      0x00000000: Contribution size = 84, Format = DWARF32, Version = 5
 ; BOTH-NEXT:      0x[[CU1_STROFF]]:
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}

llvm/trunk/test/DebugInfo/X86/string-offsets-table.ll

 ; MONOLITHIC-NEXT:     0x00000000:
 ; MONOLITHIC-NEXT:     0x[[STRING2:[0-9a-f]]]
 ; MONOLITHIC-NEXT:     0x[[STRING3:[0-9a-f]]]
 ; MONOLITHIC-NEXT:     0x[[STRING4:[0-9a-f]]]
 
 ; Verify that the .debug_str_offsets section is there and that it starts
 ; with an 8-byte header, followed by offsets into the .debug_str section.
 ; MONOLITHIC:          .debug_str_offsets contents:
-; MONOLITHIC-NEXT:     Contribution size = 32, Format = DWARF32, Version = 5
+; MONOLITHIC-NEXT:     Contribution size = 36, Format = DWARF32, Version = 5
 ; MONOLITHIC-NEXT:     0x00000008: 00000000
 ; MONOLITHIC-NEXT:     0x0000000c: [[STRING2]]
 ; MONOLITHIC-NEXT:     0x00000010: [[STRING3]]
 ; MONOLITHIC-NEXT:     0x00000014: [[STRING4]]
 
 ; For split dwarf, verify that the skeleton unit has the DW_AT_str_offsets_base
 ; attribute and that it has the right value.
 ;

 ; SPLIT:      .debug_str.dwo contents:
 ; SPLIT-NEXT: 0x00000000:{{.*}}
 ; SPLIT-NEXT: 0x[[STRING2DWO:[0-9a-f]*]]{{.*}}
 ; SPLIT-NEXT: 0x[[STRING3DWO:[0-9a-f]*]]{{.*}}
 ;
 ; Check the string offsets sections in both the main and the .dwo files and
 ; verify that the extracted string offsets are referenced correctly.
 ; SPLIT:      .debug_str_offsets contents:
-; SPLIT-NEXT: 0x00000000: Contribution size = 8, Format = DWARF32, Version = 5
+; SPLIT-NEXT: 0x00000000: Contribution size = 12, Format = DWARF32, Version = 5
 ; SPLIT-NEXT: 0x00000008: 00000000{{.*}}
 ; SPLIT-NEXT: 0x0000000c: [[STRING2SPLIT]]
 ; SPLIT:      .debug_str_offsets.dwo contents:
-; SPLIT-NEXT: 0x00000000: Contribution size = 32, Format = DWARF32, Version = 5
+; SPLIT-NEXT: 0x00000000: Contribution size = 36, Format = DWARF32, Version = 5
 ; SPLIT-NEXT: 0x00000008: 00000000{{.*}}
 ; SPLIT-NEXT: 0x0000000c: [[STRING2DWO]]{{.*}}
 ; SPLIT-NEXT: 0x00000010: [[STRING3DWO]]
 
 @glob = global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!11, !12, !13}