[DebugInfo] Check that we do not run past a line table end when parsing

[jhenderson]

Summary

This change adds another check to the debug line table parsing code, namely to make sure the final offset after parsing a table matches the end offset as expected based on the unit length field. These two won't match if the unit length points to part way through an opcode, as the parsing does not stop midway through opcodes.

If the problem is detected, the offset will be reset to the expected value and an error reported.

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

924

I guess that the comment is not 100% accurate. Let's imagine the following purely illustrative and meaningless sequence at the end of the section: 0, 5, DW_LNE_set_address, 0, 1, DW_LNE_end_sequence. The extractor will not read an argument of DW_LNE_set_address and will not increment the offset, but after that, something which looks like a correct termination will be read.

927

Maybe it is more consistent to put this code before the previous check. I mean, this check is comparatively low level, and if it triggers, the input is probably corrupted so deeply that it makes no sense to interpret it, no?

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

924

In your example, the set address opcode would consume the three bytes comprising the end sequence opcode, followed by reading a single zero value for the final byte. The offset would be adjusted to the end of the three readable bytes (thus going past the end of the DW_LNE_end_sequence opcode). The parser would then stop as *OffsetPtr == EndOffset. This warning wouldn't then be triggered but a no end sequence one would be.

Would changing this statement "As the offset isn't incremented by the data extractor when reading past the end of the available data" to "As the offset isn't incremented by the data extractor past the end of the available data" be clearer?

927

Just to be clear, are you saying that we shouldn't report the no end sequence error if we hit this case? That's fine with me. If I did that, I'd probably pull the sort below to before this check, as that would allow me to simply return after the error has been reported, whilst still allowing clients to use the data, if they want to.

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

924

Ah, yes, I forgot about the special code which fixes OffsetPtr at the end of the branch for Opcode == 0. Well, I cannot imagine another malicious sequence. It is sad that the whole code is not straightforward and requires a long explanatory comment.

I don't insist on any specific wording, but maybe it is worth to add a note about the code at the end of the Opcode == 0 branch which I missed.

927

Right, I believe that we do not need to report about the unterminated sequence if we have reported the incorrect offset. The latter is more fundamental, to my taste.

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp

178

Do I understand it right that this fix along with the corresponding changes in other places may be extracted into a separate patch?

[dblaikie]

@labath - maybe some other parts of the DWARF parsing that could benefit from a constrained DWARFDataExtractor

llvm/test/tools/llvm-dwarfdump/X86/debug_line_invalid.test

39

Should this dump in verbose mode to show more clearly which operations were parsed and which ones were not? So they match up with the LNE_* descriptions in the comments in the test?

185

(similar to other comment) - this warning sounds problematic to me & any chunk of debug info that has a specified length shouldn't be read beyond that length (as if the section itself ended at the end of the length - we should get the same error messages in both those cases)

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

568–569

This phrasing doesn't match up with not reading past the end of a specified length - I'd expect something more like "last opcode in line table at offset 0x..1 is incomplete/truncated at offset 0x...34" or the like. Maybe with "expected to extend to 0x35" if we know that some localized implied/expressed length extends beyond some broader length that was specified.

794–796

Could you explain this further? What's incorrect about the existing usage (where is the opcode length field? Is that the 0x2 in the line above? Why would it be too short? (should the DWARFGenerator API be changed? is it computing a length that's too short for the table?))

[labath]

In D73618#1850803, @dblaikie wrote:

@labath - maybe some other parts of the DWARF parsing that could benefit from a constrained DWARFDataExtractor

I think that pretty much everything would benefit from a data extractor constrained in this way. Prefixing the content with length is used in nearly every dwarf section, and so in theory, everything should be checking that it does not cross the specified length. I've seen code which attempts to do that via something like while(!endReached() && data.isValidOffset(*Offset) && *Offset < EndOffset) parseOneThing(Offset), but that is:
a) complicated
b) probably incorrect, because the end boundary is only checked at the end of the parseOneThing call, so we can still cross that boundary if the "one thing" is sitting on both sides of the boundary

If we had a "constrained" data extractor, then we wouldn't need the *Offset < EndOffset check, because the extractor would check that for us (and it would do that _everywhere_). It would also allow us to treat the "'thing' crosses a contribution boundary, but there is another contribution after it" and "'thing' crosses a contribution boundary, but hits the end of the section" cases uniformly, because as far as the code would be concerned, everything would be at the end of the section.

[labath]

In D73618#1851154, @labath wrote:

In D73618#1850803, @dblaikie wrote:

@labath - maybe some other parts of the DWARF parsing that could benefit from a constrained DWARFDataExtractor

I think that pretty much everything would benefit from a data extractor constrained in this way. Prefixing the content with length is used in nearly every dwarf section, and so in theory, everything should be checking that it does not cross the specified length. I've seen code which attempts to do that via something like while(!endReached() && data.isValidOffset(*Offset) && *Offset < EndOffset) parseOneThing(Offset), but that is:
a) complicated
b) probably incorrect, because the end boundary is only checked at the end of the parseOneThing call, so we can still cross that boundary if the "one thing" is sitting on both sides of the boundary

If we had a "constrained" data extractor, then we wouldn't need the *Offset < EndOffset check, because the extractor would check that for us (and it would do that _everywhere_). It would also allow us to treat the "'thing' crosses a contribution boundary, but there is another contribution after it" and "'thing' crosses a contribution boundary, but hits the end of the section" cases uniformly, because as far as the code would be concerned, everything would be at the end of the section.

Ok, I think I now understand (after reading the other emails) that you were letting me know of the use cases, and not asking me to provide some. :)

[jhenderson]

Given the proposed changes to the DWARFDataExtractor to limit it to a certain region, I think this and similar changes I have in the pipeline should probably be shelved, as the behaviour will change and the error messages will need updating. I'll focus on other areas instead in the meantime.

llvm/test/tools/llvm-dwarfdump/X86/debug_line_invalid.test

39

This last check is just for the last (good) section, so doesn't really need to show things in that much detail. However, I could certainly see a benefit for checking things more verbosely. We already do verbose dumps on line 29 of the test, but the checks don't check the operands. I'll look at updating that, but it should be a separate change.

185

That's fair. Saying it's been truncated at this point is somewhat lying, but would be correct once we switch to the limited data extractor.

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

568–569

I think your proposal makes sense with the proposed data extractor changes, but possibly not before. See my out-of-line comment.

794–796

addExtendedOpcode takes a length for an extended opcode, followed by the opcode itself, and then data for the operands. I realise this byte should be moved into the operands argument, so I'll fix that. I don't think the API here needs changing, as it would prevent us creating broken situations like this (i.e. an extended opcode without sufficient data for its claimed length).

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp

178

It probably can be. It's a requirement for this patch, but dosen't need to be a part of the same commit. I'lll look at splitting it out.

[dblaikie]

llvm/test/tools/llvm-dwarfdump/X86/debug_line_invalid.test

39

Oh, I figured this change related to the other change in this review (Case 13) which wasn't super clear to me & figured verbosity might help.

185

Right - I meant that the warning implies the implementation isn't what I'd hope/expect (& that both message and implementation should be fixed in the direction of not reading more than the prefixed length indicates for any given entity).

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

568–569

Right right - implementation and messaging should be fixed in that direction.

794–796

What's the mention of the "table end" here, then? I guess "table end" is indicated by the table length field elsewhere? Is it autogenerated (with a possible override for invalid situations)? Should it be autogenerated differently?

[jhenderson]

llvm/test/tools/llvm-dwarfdump/X86/debug_line_invalid.test

39

It's only indirectly related. Case 13 required adding new data to the input, which pushed the last table later, meaning the offset needed updating.

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

794–796

Yeah, the table length is auto-generated, but it's auto-generated based on the raw data we add (i.e. not the interpretation of the data, but the physical number of bytes we add). See writeDefaultPrologue in DWARFGenerator.cpp. The ability to override the length is provided by the createBasicPrologue function which returns a line table prologue that can be updated for use in the test. See e.g. ErrorForTooLargePrologueLength. I think this is a reasonable approach.

In this test case, we are overriding the DW_LNE_end_sequence length with something different, by specifying the "2" argument. Previously, by not specifying any data after it in the test, the majority of the bytes covered by this size were past the end of the table, which is itself an interesting test case, albeit not the focus of this test. Consequently it was triggering the new error, which I didn't want. When I next update this patch, I'll replace this and the previous line of code and comment with:
LT.addExtendedOpcode(0x2, DW_LNE_end_sequence, {{LineTable::Byte, 0xaa});

[jhenderson]

Abandoning in favour of D80796 and related patches.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

Error DWARFDebugLine::LineTable::parse(
 
   if (!State.Sequence.Empty)
     RecoverableErrorCallback(createStringError(
         errc::illegal_byte_sequence,
         "last sequence in debug line table at offset 0x%8.8" PRIx64
         " is not terminated",
         DebugLineOffset));
 
+  // Check that we haven't gone past the expected end of the table. This can
+  // only happen when an opcode starts before the expected end, and finishes
+  // after. As the offset isn't incremented by the data extractor when
+  // reading past the end of the available data, this will not detect cases
+  // where the overflowing opcode appears at the end of the section. However, in
+  // such cases, an unterminated sequence error will be raised instead, as the
+  // data extractor will return zeroes for the trailing bytes (which do not
+  // correspond to an end sequence instruction).
+  if (*OffsetPtr > EndOffset) {
+    RecoverableErrorCallback(createStringError(
+        errc::invalid_argument,
+        "last opcode in line table at offset 0x%8.8" PRIx64
+        " ended at offset 0x%8.8" PRIx64
+        " which is past the expected table end at offset 0x%8.8" PRIx64,
+        DebugLineOffset, *OffsetPtr, EndOffset));
+    // Recover from this error by resetting the offset back to the expected end.
+    *OffsetPtr = EndOffset;
+  }
+
   // Sort all sequences so that address lookup will work faster.
   if (!Sequences.empty()) {
     llvm::sort(Sequences, Sequence::orderByHighPC);
     // Note: actually, instruction address ranges of sequences should not
     // overlap (in shared objects and executables). If they do, the address
     // lookup would still work, though, but result would be ambiguous.
     // We don't report warning in this case. For example,
     // sometimes .so compiled from multiple object files contains a few

llvm/test/tools/llvm-dwarfdump/X86/Inputs/debug_line_malformed.s

 .asciz  "xyz"           # File name                       | 3 special opcodes + DW_LNE_set_address start
 .byte   9               # MD5 hash value                  | DW_LNE_set_address length
 # Header end
 .byte   2               # DW_LNE_set_address opcode
 .quad   0x4321432143214321
 .byte   0, 1, 1         # DW_LNE_end_sequence
 .Linvalid_md5_end1:
 
+# Opcode extends past the end of the table, as claimed by the unit length field.
+.long   .Lshort_unit_length_end - .Lshort_unit_length_start # Length of Unit
+.Lshort_unit_length_start:
+.short  4               # DWARF version number
+.long   .Lprologue_short_unit_length_end-.Lprologue_short_unit_length_start # Length of Prologue
+.Lprologue_short_unit_length_start:
+.byte   1               # Minimum Instruction Length
+.byte   1               # Maximum Operations per Instruction
+.byte   1               # Default is_stmt
+.byte   -5              # Line Base
+.byte   14              # Line Range
+.byte   13              # Opcode Base
+.byte   0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1 # Standard Opcode Lengths
+.asciz "dir1"           # Include table
+.asciz "dir2"
+.byte   0
+.asciz "file1"          # File table
+.byte   0, 0, 0
+.asciz "file2"
+.byte   1, 0, 0
+.byte   0
+.Lprologue_short_unit_length_end:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0xfeedfeed
+.byte   1               # DW_LNS_copy
+.byte   0, 9, 2         # DW_LNE_set_address
+.long   0xf001          # Truncated address (should be 8 bytes)
+.Lshort_unit_length_end:
+
 # Trailing good section.
 .long   .Lunit_good_end - .Lunit_good_start # Length of Unit (DWARF-32 format)
 .Lunit_good_start:
 .short  4               # DWARF version number
 .long   .Lprologue_good_end-.Lprologue_good_start # Length of Prologue
 .Lprologue_good_start:
 .byte   1               # Minimum Instruction Length
 .byte   1               # Maximum Operations per Instruction

llvm/test/tools/llvm-dwarfdump/X86/debug_line_invalid.test

 # RUN: FileCheck %s --input-file=%t-malformed-verbose.err --check-prefixes=ALL,OTHER
 
 ## We should still produce warnings for malformed tables after the specified unit.
 # RUN: llvm-dwarfdump -debug-line=0 %t-malformed.o 2> %t-malformed-off-first.err \
 # RUN:   | FileCheck %s --check-prefixes=FIRST,NOLATER
 # RUN: FileCheck %s --input-file=%t-malformed-off-first.err --check-prefix=ALL
 
 ## Don't stop looking for the later unit if non-fatal issues are found.
-# RUN: llvm-dwarfdump -debug-line=0x2ec %t-malformed.o 2> %t-malformed-off-last.err \
+# RUN: llvm-dwarfdump -debug-line=0x339 %t-malformed.o 2> %t-malformed-off-last.err \
 # RUN:   | FileCheck %s --check-prefix=LAST --implicit-check-not='debug_line[{{.*}}]'
 # RUN: FileCheck %s --input-file=%t-malformed-off-last.err --check-prefix=ALL
 
 # FIRST:       debug_line[0x00000000]
 # FIRST:       0x000000000badbeef {{.*}} end_sequence
 # NOFIRST-NOT: debug_line[0x00000000]
 # NOFIRST-NOT: 0x000000000badbeef {{.*}} end_sequence
 # NOLATER-NOT: debug_line[{{.*}}]

 ## been read before the MD5 problem is identified.
 # NONFATAL: debug_line[0x000002ae]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  0] = "/tmp"
 # NONFATAL-NOT:  file_names
 # NONFATAL:      0x0000000000000000 {{.*}} epilogue_begin
 # NONFATAL:      0x4321432143214321 {{.*}} is_stmt end_sequence
 
-# LAST:          debug_line[0x000002ec]
+## Case 13: Last operand goes past unit end.
+# NONFATAL:      debug_line[0x000002ec]
+# NONFATAL-NEXT: Line table prologue
+# NONFATAL:      0x00000000feedfeed {{.*}} is_stmt
+## The truncated row is not added by any operation, so is not recorded in the
+## table.
+# NONFATAL-NOT:  is_stmt
+
+# LAST:          debug_line[0x00000339]
 # LAST:          0x00000000cafebabe {{.*}} end_sequence
 
 # RESERVED: warning: parsing line table prologue at offset 0x00000048 unsupported reserved unit length found of value 0xfffffffe
 
 # ALL-NOT:  warning:
 # ALL:      warning: parsing line table prologue at offset 0x00000048 found unsupported version 0x00
 # ALL-NEXT: warning: parsing line table prologue at offset 0x0000004e found unsupported version 0x01
 # ALL-NEXT: warning: parsing line table prologue at 0x00000054 found an invalid directory or file table description at 0x00000073
 # ALL-NEXT: warning: failed to parse entry content descriptions because no path was found
 # ALL-NEXT: warning: parsing line table prologue at 0x00000081 should have ended at 0x000000b9 but it ended at 0x000000ba
 # ALL-NEXT: warning: parsing line table prologue at 0x000000c8 should have ended at 0x00000103 but it ended at 0x00000102
 # OTHER-NEXT: warning: unexpected line op length at offset 0x00000158 expected 0x02 found 0x01
 # OTHER-NEXT: warning: unexpected line op length at offset 0x0000015c expected 0x01 found 0x02
 # OTHER-NEXT: warning: last sequence in debug line table at offset 0x0000016c is not terminated
 # ALL-NEXT: warning: parsing line table prologue at 0x000001b2 should have ended at 0x000001ce but it ended at 0x000001e1
 # ALL-NEXT: warning: parsing line table prologue at 0x000001ee should have ended at 0x00000219 but it ended at 0x00000220
 # ALL-NEXT: warning: parsing line table prologue at 0x0000022f should have ended at 0x00000251 but it ended at 0x0000025e
 # ALL-NEXT: warning: parsing line table prologue at 0x0000026b found an invalid directory or file table description at 0x0000029f
 # ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
 # ALL-NEXT: warning: parsing line table prologue at 0x000002ae found an invalid directory or file table description at 0x000002e0
 # ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
 # ALL-NEXT: warning: parsing line table prologue at 0x000002ae should have ended at 0x000002d9 but it ended at 0x000002e0
+# OTHER-NEXT: warning: last sequence in debug line table at offset 0x000002ec is not terminated
+# OTHER-NEXT: warning: last opcode in line table at offset 0x000002ec ended at offset 0x0000033d which is past the expected table end at offset 0x00000339
 # ALL-NOT:  warning:

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

 TEST_P(DebugLineParameterisedFixture, ErrorForTooLargePrologueLength) {
   if (!setupGenerator(Version))
     return;
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
+  LT.addByte(0xaa);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
   ++Prologue.PrologueLength;
   LT.setPrologue(Prologue);
 
   generate();
 
   auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
                                                     nullptr, RecordRecoverable);
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   DWARFDebugLine::LineTable Result(**ExpectedLineTable);
   // Undo the earlier modification so that it can be compared against a
   // "default" prologue.
   --Result.Prologue.PrologueLength;
-  checkDefaultPrologue(Version, Format, Result.Prologue, 0);
+  checkDefaultPrologue(Version, Format, Result.Prologue, 1);
 
-  uint64_t ExpectedEnd =
-      Prologue.TotalLength + 1 + Prologue.sizeofTotalLength();
+  uint64_t ExpectedEnd = Prologue.TotalLength + Prologue.sizeofTotalLength();
   checkError(
       (Twine("parsing line table prologue at 0x00000000 should have ended at "
              "0x000000") +
        Twine::utohexstr(ExpectedEnd) + " but it ended at 0x000000" +
        Twine::utohexstr(ExpectedEnd - 1))
           .str(),
       std::move(Recoverable));
 }
TEST_F(DebugLineBasicFixture, ErrorForUnitLengthTooLarge) {
   LineTable &Padding = Gen->addLineTable();
   // Add some padding to show that a non-zero offset is handled correctly.
   Padding.setCustomPrologue({{0, LineTable::Byte}});
   LineTable &LT = Gen->addLineTable();
   LT.addStandardOpcode(DW_LNS_copy, {});
   LT.addStandardOpcode(DW_LNS_const_add_pc, {});
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
-  // Set the total length to 1 higher than the actual length. The program body
-  // has size 5.
-  Prologue.TotalLength += 6;
+  // Set the total length to 1 higher than the actual length.
+  ++Prologue.TotalLength;
   LT.setPrologue(Prologue);
 
   generate();
 
   auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 1, *Context,
                                                     nullptr, RecordRecoverable);
   checkError("line table program with offset 0x00000001 has length 0x00000034 "
              "but only 0x00000033 bytes are available",
              std::move(Recoverable));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 2u);
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
 }
 
+TEST_F(DebugLineBasicFixture, ErrorForUnitLengthTruncatingOpcode) {
+  if (!setupGenerator())
+    return;
+
+  LineTable &Padding = Gen->addLineTable();
+  // Add some padding to show that a non-zero offset is handled correctly.
+  Padding.setCustomPrologue({{0, LineTable::Byte}});
+  LineTable &LT = Gen->addLineTable();
+  LT.addStandardOpcode(DW_LNS_copy, {});
+  LT.addStandardOpcode(DW_LNS_const_add_pc, {});
+  LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+  DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
+  --Prologue.TotalLength;
+  LT.setPrologue(Prologue);
+
+  generate();
+
+  DWARFDebugLine::LineTable Table;
+  uint64_t Offset = 1;
+  ASSERT_THAT_ERROR(
+      Table.parse(LineData, &Offset, *Context, nullptr, RecordRecoverable),
+      Succeeded());
+  checkError(
+      "last opcode in line table at offset 0x00000001 ended at offset "
+      "0x00000034 which is past the expected table end at offset 0x00000033",
+      std::move(Recoverable));
+  EXPECT_EQ(Table.Rows.size(), 2u);
+  EXPECT_EQ(Table.Sequences.size(), 1u);
+  // Show that the output offset is based on the unit length, not the actual
+  // amount of data parsed.
+  EXPECT_EQ(Offset, Prologue.TotalLength + Prologue.sizeofTotalLength() + 1);
+}
+
 TEST_F(DebugLineBasicFixture, ErrorForMismatchedAddressSize) {
   if (!setupGenerator(4, 8))
     return;
 
   LineTable &LT = Gen->addLineTable();
   // The line data extractor expects size 8 (Quad) addresses.
   uint64_t Addr1 = 0x11223344;
   LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}});
checkError({"parsing line table prologue at offset 0x00000000 found "
              std::move(Unrecoverable));
 }
 
 TEST_F(DebugLineBasicFixture, ParserReportsNonPrologueProblemsWhenParsing) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable(DWARF32);
-  LT.addExtendedOpcode(0x42, DW_LNE_end_sequence, {});
+  LT.addExtendedOpcode(0x2, DW_LNE_end_sequence, {});
+  // Arbitrary padding byte to ensure the end of the opcode as claimed by the
+  // opcode length field does not go past the table end.
+  LT.addByte(0xaa);
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.addExtendedOpcode(9, DW_LNE_set_address,
                         {{0x1234567890abcdef, LineTable::Quad}});
   LT2.addStandardOpcode(DW_LNS_copy, {});
   LT2.addByte(0xbb);
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs);
   Parser.parseNext(RecordRecoverable, RecordUnrecoverable);
   EXPECT_FALSE(Unrecoverable);
   ASSERT_FALSE(Parser.done());
   checkError(
-      "unexpected line op length at offset 0x00000030 expected 0x42 found 0x01",
+      "unexpected line op length at offset 0x00000030 expected 0x02 found 0x01",
       std::move(Recoverable));
 
   // Reset the error state so that it does not confuse the next set of checks.
   Unrecoverable = Error::success();
   Parser.parseNext(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_TRUE(Parser.done());
-  checkError("last sequence in debug line table at offset 0x00000031 is not "
+  checkError("last sequence in debug line table at offset 0x00000032 is not "
              "terminated",
              std::move(Recoverable));
   EXPECT_FALSE(Unrecoverable);
 }
 
 TEST_F(DebugLineBasicFixture,
        ParserReportsPrologueErrorsInEachTableWhenSkipping) {
   if (!setupGenerator())

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp

case 5:
     break;
   default:
     llvm_unreachable("unsupported version");
   }
   if (Format == DWARF64) {
     P.TotalLength += 4;
     P.FormParams.Format = DWARF64;
   }
+  P.TotalLength += Contents.size();
   P.FormParams.Version = Version;
   P.MinInstLength = 1;
   P.MaxOpsPerInst = 1;
   P.DefaultIsStmt = 1;
   P.LineBase = -5;
   P.LineRange = 14;
   P.OpcodeBase = 13;
   P.StandardOpcodeLengths = {0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1};