[DebugInfo] Relax some checking in the debug line parser

[jhenderson]

Summary

The debug line parser was being overly conservative in its checking in some areas. This change removes some checks, and modifies the parser to attempt to recover from more situations where something looks wrong. In cases where a length doesn't match what has been read, parsing is now resumed from the later position (i.e. std::max(OldOffset + Length, CurrentOffset)).

This patch also improves some related testing to make it easier to see what the test is doing.

[ikudrin]

It looks like lld/test/ELF/undef.s comes here by accident, right?

[jhenderson]

In D71702#1791172, @ikudrin wrote:

It looks like lld/test/ELF/undef.s comes here by accident, right?

Nope, it's intentional. Beacuse I've relaxed the severity of prologue errors so that the parsing can continue, LLD test no longer fails to load the line information for the undefined reference that has a slightly dodgy line table. For reference, I added the --implicit-check-not to make sure I hadn't missed anything when verifying that test still achieved its main goal. Given that LLD should only emit the bad line table information once, I think it's a worthwhile addition too.

[dblaikie]

Seems like a lot of changes that could probably be split out into independent patches that'd be easier to review/validate tests, etc?

Some of this includes comments to existing codepaths, for instance - they should proabbly go in separately.

& I'm guessing each change to a recoverable error can probably be committed and tested independently?

[jhenderson]

In D71702#1792118, @dblaikie wrote:

Seems like a lot of changes that could probably be split out into independent patches that'd be easier to review/validate tests, etc?

Some of this includes comments to existing codepaths, for instance - they should proabbly go in separately.

& I'm guessing each change to a recoverable error can probably be committed and tested independently?

Yes, you're probably right. I'll take a look at splitting things up more. This is my last day in the office before the New Year. I might get some patches done, but the whole series will likely not be finished until I'm back.

[jhenderson]

I've put up a series of patches that addresses most of the patch issues that I've fixed with this patch, starting from D71752. I'll continue adding to it as I get time today, and in the New Year, if I don't finish before I leave the office.

[jhenderson]

I've created a whole series of patches to replace this, some of which have already landed. The remainder are D72154, D72155, D72156, D72157, D72158, and D72159.

lld/test/ELF/undef.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef-debug.s -o %t3.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef-bad-debug.s -o %t4.o
 # RUN: rm -f %t2.a
 # RUN: llvm-ar rc %t2.a %t2.o
-# RUN: not ld.lld %t.o %t2.a %t3.o %t4.o -o %t.exe 2>&1 | FileCheck %s
-# RUN: not ld.lld -pie %t.o %t2.a %t3.o %t4.o -o %t.exe 2>&1 | FileCheck %s
+# RUN: not ld.lld %t.o %t2.a %t3.o %t4.o -o %t.exe 2>&1 \
+# RUN:   | FileCheck %s --implicit-check-not="error:" --implicit-check-not="warning:"
+# RUN: not ld.lld -pie %t.o %t2.a %t3.o %t4.o -o %t.exe 2>&1 \
+# RUN:   | FileCheck %s --implicit-check-not="error:" --implicit-check-not="warning:"
 
 # CHECK: error: undefined symbol: foo
 # CHECK: >>> referenced by undef.s
 # CHECK:                   {{.*}}:(.text+0x1)
 
 # CHECK: error: undefined symbol: bar
 # CHECK: >>> referenced by undef.s
 # CHECK: >>>               {{.*}}:(.text+0x6)

 # CHECK: >>> referenced by undef-debug.s:11 (dir{{/|\\}}undef-debug.s:11)
 # CHECK: >>>               {{.*}}.o:(.text.2+0x0)
 
 # Show that all line table problems are mentioned as soon as the object's line information
 # is requested, even if that particular part of the line information is not currently required.
 # CHECK: warning: parsing line table prologue at 0x00000000 should have ended at 0x00000038 but it ended at 0x00000037
 # CHECK: warning: last sequence in debug line table is not terminated!
 # CHECK: error: undefined symbol: zed6
-# CHECK: >>> referenced by {{.*}}tmp4.o:(.text+0x0)
+# CHECK: >>> referenced by undef-bad-debug.s:11 (dir{{/|\\}}undef-bad-debug.s:11)
+# CHECK: >>>               {{.*}}tmp4.o:(.text+0x0)
 
 # Show that a problem with one line table's information doesn't affect getting information from
 # a different one in the same object.
 # CHECK: error: undefined symbol: zed7
 # CHECK: >>> referenced by undef-bad-debug2.s:11 (dir2{{/|\\}}undef-bad-debug2.s:11)
 # CHECK: >>>               {{.*}}tmp4.o:(.text+0x8)
 
 # RUN: not ld.lld %t.o %t2.a -o %t.exe -no-demangle 2>&1 | \

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

struct Prologue {
     getFileNameByIndex(uint64_t FileIndex, StringRef CompDir,
                        DILineInfoSpecifier::FileLineInfoKind Kind,
                        std::string &Result,
                        sys::path::Style Style = sys::path::Style::native) const;
 
     void clear();
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     Error parse(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
+                std::function<void(Error)> RecoverableErrorCallback,
                 const DWARFContext &Ctx, const DWARFUnit *U = nullptr);
   };
 
   /// Standard .debug_line state machine structure.
   struct Row {
     explicit Row(bool DefaultIsStmt = false);
 
     /// Called after a row is appended to the matrix.
public:
     parseNext(
         function_ref<void(Error)> RecoverableErrorCallback,
         function_ref<void(Error)> UnrecoverableErrorCallback,
         raw_ostream *OS = nullptr);
 
     /// Skip the current line table and go to the following line table (if
     /// present) immediately.
     ///
-    /// \param ErrorCallback - report any prologue parsing issues via this
-    /// callback.
-    void skip(function_ref<void(Error)> ErrorCallback);
+    /// \param RecoverableErrorCallback - report any recoverable prologue
+    /// parsing issues via this callback.
+    /// \param UnrecoverableErrorCallback - report any unrecoverable prologue
+    /// parsing issues via this callback.
+    void skip(function_ref<void(Error)> RecoverableErrorCallback,
+              function_ref<void(Error)> UnrecoverableErrorCallback);
 
     /// Indicates if the parser has parsed as much as possible.
     ///
     /// \note Certain problems with the line table structure might mean that
     /// parsing stops before the end of the section is reached.
     bool done() const { return Done; }
 
     /// Get the offset the parser has reached.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

while (set.extract(arangesData, &offset))
       set.dump(OS);
   }
 
   auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
                              DIDumpOptions DumpOpts,
                              Optional<uint64_t> DumpOffset) {
     while (!Parser.done()) {
       if (DumpOffset && Parser.getOffset() != *DumpOffset) {
-        Parser.skip(dumpWarning);
+        Parser.skip(dumpWarning, dumpWarning);
         continue;
       }
       OS << "debug_line[" << format("0x%8.8" PRIx64, Parser.getOffset())
          << "]\n";
       if (DumpOpts.Verbose) {
         Parser.parseNext(dumpWarning, dumpWarning, &OS);
       } else {
         DWARFDebugLine::LineTable LineTable =

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

parseV2DirFileTables(const DWARFDataExtractor &DebugLineData,
   ContentTypes.HasLength = true;
 }
 
 // Parse v5 directory/file entry content descriptions.
 // Returns the descriptors, or an error if we did not find a path or ran off
 // the end of the prologue.
 static llvm::Expected<ContentDescriptors>
 parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
-                   uint64_t EndPrologueOffset,
                    DWARFDebugLine::ContentTypeTracker *ContentTypes) {
   ContentDescriptors Descriptors;
   int FormatCount = DebugLineData.getU8(OffsetPtr);
   bool HasPath = false;
   for (int I = 0; I != FormatCount; ++I) {
-    if (*OffsetPtr >= EndPrologueOffset)
-      return createStringError(
-          errc::invalid_argument,
-          "failed to parse entry content descriptions at offset "
-          "0x%8.8" PRIx64
-          " because offset extends beyond the prologue end at offset "
-          "0x%8.8" PRIx64,
-          *OffsetPtr, EndPrologueOffset);
     ContentDescriptor Descriptor;
     Descriptor.Type =
       dwarf::LineNumberEntryFormat(DebugLineData.getULEB128(OffsetPtr));
     Descriptor.Form = dwarf::Form(DebugLineData.getULEB128(OffsetPtr));
     if (Descriptor.Type == dwarf::DW_LNCT_path)
       HasPath = true;
     if (ContentTypes)
       ContentTypes->trackContentType(Descriptor.Type);
     Descriptors.push_back(Descriptor);
   }
 
   if (!HasPath)
     return createStringError(errc::invalid_argument,
                              "failed to parse entry content descriptions"
                              " because no path was found");
   return Descriptors;
 }
 
 static Error
 parseV5DirFileTables(const DWARFDataExtractor &DebugLineData,
-                     uint64_t *OffsetPtr, uint64_t EndPrologueOffset,
-                     const dwarf::FormParams &FormParams,
+                     uint64_t *OffsetPtr, const dwarf::FormParams &FormParams,
                      const DWARFContext &Ctx, const DWARFUnit *U,
                      DWARFDebugLine::ContentTypeTracker &ContentTypes,
                      std::vector<DWARFFormValue> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   // Get the directory entry description.
   llvm::Expected<ContentDescriptors> DirDescriptors =
-      parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset, nullptr);
+      parseV5EntryFormat(DebugLineData, OffsetPtr, nullptr);
   if (!DirDescriptors)
     return DirDescriptors.takeError();
 
   // Get the directory entries, according to the format described above.
   int DirEntryCount = DebugLineData.getU8(OffsetPtr);
   for (int I = 0; I != DirEntryCount; ++I) {
-    if (*OffsetPtr >= EndPrologueOffset)
-      return createStringError(
-          errc::invalid_argument,
-          "failed to parse directory entry at offset "
-          "0x%8.8" PRIx64
-          " because offset extends beyond the prologue end at offset "
-          "0x%8.8" PRIx64,
-          *OffsetPtr, EndPrologueOffset);
     for (auto Descriptor : *DirDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
       switch (Descriptor.Type) {
       case DW_LNCT_path:
         if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
           return createStringError(errc::invalid_argument,
                                    "failed to parse directory entry because "
                                    "extracting the form value failed.");
         IncludeDirectories.push_back(Value);
         break;
       default:
         if (!Value.skipValue(DebugLineData, OffsetPtr, FormParams))
           return createStringError(errc::invalid_argument,
                                    "failed to parse directory entry because "
                                    "skipping the form value failed.");
       }
     }
   }
 
   // Get the file entry description.
   llvm::Expected<ContentDescriptors> FileDescriptors = parseV5EntryFormat(
-      DebugLineData, OffsetPtr, EndPrologueOffset, &ContentTypes);
+      DebugLineData, OffsetPtr, &ContentTypes);
   if (!FileDescriptors)
     return FileDescriptors.takeError();
 
   // Get the file entries, according to the format described above.
   int FileEntryCount = DebugLineData.getU8(OffsetPtr);
   for (int I = 0; I != FileEntryCount; ++I) {
-    if (*OffsetPtr >= EndPrologueOffset)
-      return createStringError(
-          errc::invalid_argument,
-          "failed to parse file entry at offset "
-          "0x%8.8" PRIx64
-          " because offset extends beyond the prologue end at offset "
-          "0x%8.8" PRIx64,
-          *OffsetPtr, EndPrologueOffset);
     DWARFDebugLine::FileNameEntry FileEntry;
     for (auto Descriptor : *FileDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
       if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
         return createStringError(errc::invalid_argument,
                                  "failed to parse file entry because "
                                  "extracting the form value failed.");
       switch (Descriptor.Type) {
for (auto Descriptor : *FileDescriptors) {
         break;
       }
     }
     FileNames.push_back(FileEntry);
   }
   return Error::success();
 }
 
-Error DWARFDebugLine::Prologue::parse(const DWARFDataExtractor &DebugLineData,
-                                      uint64_t *OffsetPtr,
-                                      const DWARFContext &Ctx,
-                                      const DWARFUnit *U) {
+Error DWARFDebugLine::Prologue::parse(
+    const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
+    std::function<void(Error)> RecoverableErrorCallback,
+    const DWARFContext &Ctx, const DWARFUnit *U) {
   const uint64_t PrologueOffset = *OffsetPtr;
 
   clear();
   TotalLength = DebugLineData.getRelocatedValue(4, OffsetPtr);
   if (TotalLength == dwarf::DW_LENGTH_DWARF64) {
     FormParams.Format = dwarf::DWARF64;
     TotalLength = DebugLineData.getU64(OffsetPtr);
   } else if (TotalLength >= dwarf::DW_LENGTH_lo_reserved) {
-    return createStringError(errc::invalid_argument,
+    // Treat this error as unrecoverable - we have no way of knowing where the
+    // table ends.
+    return createStringError(
+        errc::invalid_argument,
         "parsing line table prologue at offset 0x%8.8" PRIx64
         " unsupported reserved unit length found of value 0x%8.8" PRIx64,
         PrologueOffset, TotalLength);
   }
   FormParams.Version = DebugLineData.getU16(OffsetPtr);
   if (getVersion() < 2)
-    return createStringError(errc::not_supported,
-                       "parsing line table prologue at offset 0x%8.8" PRIx64
-                       " found unsupported version 0x%2.2" PRIx16,
-                       PrologueOffset, getVersion());
+    // Treat this error as unrecoverable - we cannot be sure what any of
+    // the data represents including the length field, so cannot skip it or make
+    // any reasonable assumptions.
+    return createStringError(
+        errc::not_supported,
 
   if (getVersion() >= 5) {
     FormParams.AddrSize = DebugLineData.getU8(OffsetPtr);
     assert((DebugLineData.getAddressSize() == 0 ||
             DebugLineData.getAddressSize() == getAddressSize()) &&
            "Line table header and data extractor disagree");
     SegSelectorSize = DebugLineData.getU8(OffsetPtr);
   }
Error DWARFDebugLine::Prologue::parse(
 
   StandardOpcodeLengths.reserve(OpcodeBase - 1);
   for (uint32_t I = 1; I < OpcodeBase; ++I) {
     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
     StandardOpcodeLengths.push_back(OpLen);
   }
 
   if (getVersion() >= 5) {
-    if (Error e = parseV5DirFileTables(
-            DebugLineData, OffsetPtr, EndPrologueOffset, FormParams, Ctx, U,
+    if (Error E =
+            parseV5DirFileTables(DebugLineData, OffsetPtr, FormParams, Ctx, U,
                                  ContentTypes, IncludeDirectories, FileNames)) {
-      return joinErrors(
+      RecoverableErrorCallback(joinErrors(
           createStringError(
               errc::invalid_argument,
               "parsing line table prologue at 0x%8.8" PRIx64
               " found an invalid directory or file table description at"
               " 0x%8.8" PRIx64,
               PrologueOffset, *OffsetPtr),
-          std::move(e));
+          std::move(E)));
+      // Skip to the end of the prologue, since the chances are that the parser
+      // did not read the whole table. This prevents the length check from
+      // executing.
+      if (*OffsetPtr < EndPrologueOffset)
+        *OffsetPtr = EndPrologueOffset;
     }
   } else
     parseV2DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
                          ContentTypes, IncludeDirectories, FileNames);
 
   if (*OffsetPtr != EndPrologueOffset)
-    return createStringError(errc::invalid_argument,
-                       "parsing line table prologue at 0x%8.8" PRIx64
-                       " should have ended at 0x%8.8" PRIx64
-                       " but it ended at 0x%8.8" PRIx64,
-                       PrologueOffset, EndPrologueOffset, *OffsetPtr);
+    RecoverableErrorCallback(createStringError(
+        errc::invalid_argument,
+        " should have ended at 0x%8.8" PRIx64 " but it ended at 0x%8.8" PRIx64,
+        PrologueOffset, EndPrologueOffset, *OffsetPtr));
+  if (*OffsetPtr < EndPrologueOffset)
+    *OffsetPtr = EndPrologueOffset;
   return Error::success();
 }
 
 DWARFDebugLine::Row::Row(bool DefaultIsStmt) { reset(DefaultIsStmt); }
 
 void DWARFDebugLine::Row::postAppend() {
   Discriminator = 0;
   BasicBlock = false;

 Error DWARFDebugLine::LineTable::parse(
     DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
     const DWARFContext &Ctx, const DWARFUnit *U,
     std::function<void(Error)> RecoverableErrorCallback, raw_ostream *OS) {
   const uint64_t DebugLineOffset = *OffsetPtr;
 
   clear();
 
-  Error PrologueErr = Prologue.parse(DebugLineData, OffsetPtr, Ctx, U);
+  Error PrologueErr = Prologue.parse(DebugLineData, OffsetPtr,
+                                     RecoverableErrorCallback, Ctx, U);
 
   if (OS) {
     // The presence of OS signals verbose dumping.
     DIDumpOptions DumpOptions;
     DumpOptions.Verbose = true;
     Prologue.dump(*OS, DumpOptions);
   }
 
if (Opcode == 0) {
         // operand is the size appropriate to hold an address on the target
         // machine. Set the address register to the value given by the
         // relocatable address. All of the other statement program opcodes
         // that affect the address register add a delta to it. This instruction
         // stores a relocatable value into it instead.
         //
         // Make sure the extractor knows the address size.  If not, infer it
         // from the size of the operand.
-        if (DebugLineData.getAddressSize() == 0)
+        {
+          uint8_t ExtractorAddressSize = DebugLineData.getAddressSize();
+          // Assume that the line table is correct and parse accordingly,
+          // before resetting the address size later on, if it didn't match.
           DebugLineData.setAddressSize(Len - 1);
-        else if (DebugLineData.getAddressSize() != Len - 1) {
-          return createStringError(errc::invalid_argument,
-                             "mismatching address size at offset 0x%8.8" PRIx64
-                             " expected 0x%2.2" PRIx8 " found 0x%2.2" PRIx64,
-                             ExtOffset, DebugLineData.getAddressSize(),
-                             Len - 1);
+          if (ExtractorAddressSize == 0) {
+            ExtractorAddressSize = Len - 1;
+          } else if (ExtractorAddressSize != Len - 1) {
+            RecoverableErrorCallback(createStringError(
+                errc::invalid_argument,
+                ExtOffset, ExtractorAddressSize, Len - 1));
           }
           State.Row.Address.Address = DebugLineData.getRelocatedAddress(
               OffsetPtr, &State.Row.Address.SectionIndex);
+          DebugLineData.setAddressSize(ExtractorAddressSize);
           if (OS)
             *OS << format(" (0x%16.16" PRIx64 ")", State.Row.Address.Address);
+        }
         break;
 
       case DW_LNE_define_file:
         // Takes 4 arguments. The first is a null terminated string containing
         // a source file name. The second is an unsigned LEB128 number
         // representing the directory index of the directory in which the file
         // was found. The third is an unsigned LEB128 number representing the
         // time of last modification of the file. The fourth is an unsigned
if (Opcode == 0) {
           *OS << format("Unrecognized extended op 0x%02.02" PRIx8, SubOpcode)
               << format(" length %" PRIx64, Len);
         // Len doesn't include the zero opcode byte or the length itself, but
         // it does include the sub_opcode, so we have to adjust for that.
         (*OffsetPtr) += Len - 1;
         break;
       }
       // Make sure the stated and parsed lengths are the same.
-      // Otherwise we have an unparseable line-number program.
-      if (*OffsetPtr - ExtOffset != Len)
-        return createStringError(errc::illegal_byte_sequence,
-                           "unexpected line op length at offset 0x%8.8" PRIx64
-                           " expected 0x%2.2" PRIx64 " found 0x%2.2" PRIx64,
-                           ExtOffset, Len, *OffsetPtr - ExtOffset);
+      // If they aren't, continue from the offset that is greater.
+      uint64_t End = ExtOffset + Len;
+      if (*OffsetPtr != End) {
+        RecoverableErrorCallback(createStringError(
+            errc::illegal_byte_sequence,
+            ExtOffset, Len, *OffsetPtr - ExtOffset));
+        if (*OffsetPtr < End)
+          *OffsetPtr = End;
+      }
     } else if (Opcode < Prologue.OpcodeBase) {
       if (OS)
         *OS << LNStandardString(Opcode);
       switch (Opcode) {
       // Standard Opcodes
       case DW_LNS_copy:
         // Takes no arguments. Append a row to the matrix using the
         // current values of the state-machine registers.
DWARFDebugLine::LineTable DWARFDebugLine::SectionParser::parseNext(
   if (Error Err = LT.parse(DebugLineData, &Offset, Context, U,
                            RecoverableErrorCallback, OS))
     UnrecoverableErrorCallback(std::move(Err));
   moveToNextTable(OldOffset, LT.Prologue);
   return LT;
 }
 
 void DWARFDebugLine::SectionParser::skip(
-    function_ref<void(Error)> ErrorCallback) {
+    function_ref<void(Error)> RecoverableErrorCallback,
+    function_ref<void(Error)> UnrecoverableErrorCallback) {
   assert(DebugLineData.isValidOffset(Offset) &&
          "parsing should have terminated");
   DWARFUnit *U = prepareToParse(Offset);
   uint64_t OldOffset = Offset;
   LineTable LT;
-  if (Error Err = LT.Prologue.parse(DebugLineData, &Offset, Context, U))
-    ErrorCallback(std::move(Err));
+  if (Error Err = LT.Prologue.parse(DebugLineData, &Offset,
+                                    RecoverableErrorCallback, Context, U))
+    UnrecoverableErrorCallback(std::move(Err));
   moveToNextTable(OldOffset, LT.Prologue);
 }
 
 DWARFUnit *DWARFDebugLine::SectionParser::prepareToParse(uint64_t Offset) {
   DWARFUnit *U = nullptr;
   auto It = LineToUnit.find(Offset);
   if (It != LineToUnit.end())
     U = It->second;

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

 .Lprologue_v5_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
-.byte   0               # directory table (invalid)
+.byte   0               # directory table (invalid as no path component)
 .Lprologue_v5_end:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0x8877665544332211
+.byte   0, 1, 1         # DW_LNE_end_sequence
 .Lunit_v5_end:
 
 # Short prologue
 .long   .Lunit_short_prologue_end - .Lunit_short_prologue_start # unit length
 .Lunit_short_prologue_start:
 .short  4               # version
-.long   .Lprologue_short_prologue_end-.Lprologue_short_prologue_start - 2 # Length of Prologue
+.long   .Lprologue_short_prologue_end-.Lprologue_short_prologue_start - 1 # Length of Prologue
 .Lprologue_short_prologue_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
+.byte   1, 2, 3
+# FIXME: There should be an additional 0 byte here, but the file name parsing
+#        code does not recognise a missing null terminator.
 .Lprologue_short_prologue_end:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0x1122334455667788
+.byte   0, 1, 1         # DW_LNE_end_sequence
 .Lunit_short_prologue_end:
 
 # Over-long prologue
 .long   .Lunit_long_prologue_end - .Lunit_long_prologue_start # unit length
 .Lunit_long_prologue_start:
 .short  4               # version
-.long   .Lprologue_long_prologue_end-.Lprologue_long_prologue_start + 1 # Length of Prologue
+.long   .Lprologue_long_prologue_end-.Lprologue_long_prologue_start # Length of Prologue
 .Lprologue_long_prologue_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   1, 2, 3
 .byte   0
+# Skipped byte (treated as part of prologue). Would be DW_LNS_negate_stmt.
+.byte   6
 .Lprologue_long_prologue_end:
+.byte   0, 9, 2        # DW_LNE_set_address
+.quad   0x1111222233334444
+.byte   0, 1, 1        # DW_LNE_end_sequence
 .Lunit_long_prologue_end:
 
-# Over-long extended opcode
+# Incorrect length extended opcodes.
 .long   .Lunit_long_opcode_end - .Lunit_long_opcode_start # unit length
 .Lunit_long_opcode_start:
 .short  4               # version
 .long   .Lprologue_long_opcode_end-.Lprologue_long_opcode_start # Length of Prologue
 .Lprologue_long_opcode_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_long_opcode_end:
 .byte   0, 9, 2        # DW_LNE_set_address
 .quad   0xabbadaba
-.byte   0, 2, 1         # DW_LNE_end_sequence (wrong length)
+.byte   0, 2, 1        # DW_LNE_end_sequence (too long)
+.byte   6              # DW_LNS_negate_stmt (but will be consumed with the end sequence above).
+.byte   0, 1, 4        # DW_LNE_set_discriminator (too short)
+.byte   0xa            # Parsed as argument for set_discriminator and not DW_LNS_set_prologue_end.
 .byte   0, 9, 2        # DW_LNE_set_address
 .quad   0xbabb1e45
-.byte   0, 1, 1         # DW_LNE_end_sequence (wrong length)
+.byte   0, 1, 1        # DW_LNE_end_sequence
 .Lunit_long_opcode_end:
 
 # No end of sequence
 .long   .Lunit_no_eos_end - .Lunit_no_eos_start # unit length
 .Lunit_no_eos_start:
 .short  4               # version
 .long   .Lprologue_no_eos_end-.Lprologue_no_eos_start # Length of Prologue
 .Lprologue_no_eos_start:

 .byte   1, 0, 0
 .byte   0
 .Lprologue_no_eos_end:
 .byte   0, 9, 2        # DW_LNE_set_address
 .quad   0xdeadfade
 .byte   1              # DW_LNS_copy
 .Lunit_no_eos_end:
 
-# Invalid prologue length
+# V5 very short prologue length.
 .long   .Linvalid_description_end0-.Linvalid_description_start0   # Length of Unit
 .Linvalid_description_start0:
 .short  5               # DWARF version number
 .byte   8               # Address Size
 .byte   0               # Segment Selector Size
 .long   15              # Length of Prologue (invalid)
 .Linvalid_description_params0:
 .byte   1               # Minimum Instruction Length

 .byte   2               # 2 elements per file entry
 .byte   1               # DW_LNCT_path
 .byte   0x08            # DW_FORM_string
 .byte   2               # DW_LNCT_directory_index
 .byte   0x0b            # DW_FORM_data1
 # File table entries
 .byte   1               # 1 file
 .asciz  "a.c"
-.byte   0
+.byte   1
 .Linvalid_description_header_end0:
-.byte   0,2,4,1         # DW_LNE_set_discriminator 1
-.byte   1               # DW_LNS_copy
-.byte   33              # address += 1, line += 1
-.byte   0,1,1           # DW_LNE_end_sequence
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0xbabb1ebabb1e
+.byte   0, 1, 1         # DW_LNE_end_sequence
 .Linvalid_description_end0:
 
-# Invalid file entry
+# V5 prologue ends during file table.
 .long   .Linvalid_file_end0-.Linvalid_file_start0   # Length of Unit
 .Linvalid_file_start0:
 .short  5               # DWARF version number
 .byte   8               # Address Size
 .byte   0               # Segment Selector Size
 .long   .Linvalid_file_header_end0-.Linvalid_file_params0-7     # Length of Prologue (invalid)
 .Linvalid_file_params0:
 .byte   1               # Minimum Instruction Length

 .byte   2               # 2 elements per file entry
 .byte   1               # DW_LNCT_path
 .byte   0x08            # DW_FORM_string
 .byte   2               # DW_LNCT_directory_index
 .byte   0x0b            # DW_FORM_data1
 # File table entries
 .byte   1               # 1 file
 .asciz  "a.c"
-.byte   0
+.byte   1
 .Linvalid_file_header_end0:
-.byte   0,2,4,1         # DW_LNE_set_discriminator 1
-.byte   1               # DW_LNS_copy
-.byte   33              # address += 1, line += 1
-.byte   0,1,1           # DW_LNE_end_sequence
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0xab4acadab4a
+.byte   0, 1, 1         # DW_LNE_end_sequence
 .Linvalid_file_end0:
 
-# Invalid directory entry
+# V5 prologue ends during directory table.
 .long   .Linvalid_dir_end0-.Linvalid_dir_start0   # Length of Unit
 .Linvalid_dir_start0:
 .short  5               # DWARF version number
 .byte   8               # Address Size
 .byte   0               # Segment Selector Size
 .long   .Linvalid_dir_header_end0-.Linvalid_dir_params0-16     # Length of Prologue (invalid)
 .Linvalid_dir_params0:
 .byte   1               # Minimum Instruction Length

 .byte   2               # 2 elements per file entry
 .byte   1               # DW_LNCT_path
 .byte   0x08            # DW_FORM_string
 .byte   2               # DW_LNCT_directory_index
 .byte   0x0b            # DW_FORM_data1
 # File table entries
 .byte   1               # 1 file
 .asciz  "a.c"
-.byte   0
+.byte   1
 .Linvalid_dir_header_end0:
-.byte   0,2,4,1         # DW_LNE_set_discriminator 1
-.byte   1               # DW_LNS_copy
-.byte   33              # address += 1, line += 1
-.byte   0,1,1           # DW_LNE_end_sequence
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0x4444333322221111
+.byte   0, 1, 1         # DW_LNE_end_sequence
 .Linvalid_dir_end0:
 
-# Invalid MD5 hash
+# Invalid MD5 hash, where there is data still to be read afterwards.
 .long   .Linvalid_md5_end0-.Linvalid_md5_start0   # Length of Unit
 .Linvalid_md5_start0:
 .short  5               # DWARF version number
 .byte   8               # Address Size
 .byte   0               # Segment Selector Size
-.long   .Linvalid_md5_header_end0-.Linvalid_md5_params0     # Length of Prologue (invalid)
+.long   .Linvalid_md5_header_end0-.Linvalid_md5_params0     # Length of Prologue
 .Linvalid_md5_params0:
 .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
 # Directory table format
 .byte   1               # One element per directory entry
 .byte   1               # DW_LNCT_path
 .byte   0x08            # DW_FORM_string
 # Directory table entries
 .byte   1               # 1 directory
 .asciz  "/tmp"
 # File table format
-.byte   3               # 2 elements per file entry
+.byte   3               # 3 elements per file entry
 .byte   1               # DW_LNCT_path
 .byte   0x08            # DW_FORM_string
+.byte   5               # DW_LNCT_MD5
+.byte   0x0b            # DW_FORM_data1
 .byte   2               # DW_LNCT_directory_index
 .byte   0x0b            # DW_FORM_data1
-.byte   5               # DW_LNCT_MD5
-.byte   0x09            # DW_FORM_data1
 # File table entries
 .byte   1               # 1 file
 .asciz  "a.c"
 .byte   0
+# Data to show that the rest of the prologue is skipped.
+.byte   6               # Would be interpreted as DW_LNS_negate_stmt.
 .Linvalid_md5_header_end0:
-.byte   0,2,4,1         # DW_LNE_set_discriminator 1
-.byte   1               # DW_LNS_copy
-.byte   33              # address += 1, line += 1
-.byte   0,1,1           # DW_LNE_end_sequence
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0x1234123412341234
+.byte   0, 1, 1         # DW_LNE_end_sequence
 .Linvalid_md5_end0:
 
+# Invalid MD5 hash, when data beyond the prologue length has
+# been read before the MD5 problem is identified.
+.long   .Linvalid_md5_end1-.Linvalid_md5_start1   # Length of Unit
+.Linvalid_md5_start1:
+.short  5               # DWARF version number
+.byte   8               # Address Size
+.byte   0               # Segment Selector Size
+.long   .Linvalid_md5_header_end1-.Linvalid_md5_params1 - 10 # Length of Prologue
+.Linvalid_md5_params1:
+.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
+# Directory table format
+.byte   1               # One element per directory entry
+.byte   1               # DW_LNCT_path
+.byte   0x08            # DW_FORM_string
+# Directory table entries
+.byte   1               # 1 directory
+.asciz  "/tmp"
+# File table format
+.byte   3               # 2 elements per file entry
+.byte   1               # DW_LNCT_path
+.byte   0x08            # DW_FORM_string
+.byte   5               # DW_LNCT_MD5
+.byte   0x0b            # DW_FORM_data1
+.byte   2               # DW_LNCT_directory_index
+.byte   0x0b            # DW_FORM_data1
+# File table entries
+.byte   1               # 1 file
+.asciz  "a.c"
+.byte   6               # This byte will be consumed when reading the MD5 value and
+                        # not interpreted as DW_LNS_negate_stmt.
+.byte   0xb             # This byte will not be read as part of the prologue, and
+                        # treated as part of the line table (DW_LNS_set_epilogue_begin).
+.Linvalid_md5_header_end1:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0x4321432143214321
+.byte   0, 1, 1         # DW_LNE_end_sequence
+.Linvalid_md5_end1:
+
 # 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

-# Test the different error cases in the debug line parsing and how they prevent
-# or don't prevent further dumping of section contents.
+## Test the different error cases in the debug line parsing and how they prevent
+## or don't prevent further dumping of section contents.
 
 # RUN: llvm-mc -triple x86_64-pc-linux %S/Inputs/debug_line_reserved_length.s -filetype=obj -o %t-reserved.o
-# RUN: llvm-dwarfdump -debug-line %t-reserved.o 2> %t-reserved.err | FileCheck %s --check-prefixes=FIRST,FATAL
+# RUN: llvm-dwarfdump -debug-line %t-reserved.o 2> %t-reserved.err \
+# RUN:   | FileCheck %s --check-prefixes=FIRST,FATAL
 # RUN: FileCheck %s --input-file=%t-reserved.err --check-prefix=RESERVED
-# RUN: llvm-dwarfdump -debug-line %t-reserved.o -verbose 2> %t-reserved-verbose.err | FileCheck %s --check-prefixes=FIRST,FATAL
+# RUN: llvm-dwarfdump -debug-line %t-reserved.o -verbose 2> %t-reserved-verbose.err \
+# RUN:   | FileCheck %s --check-prefixes=FIRST,FATAL
 # RUN: FileCheck %s --input-file=%t-reserved-verbose.err --check-prefix=RESERVED
 
 # We should still produce warnings for malformed tables after the specified unit.
-# RUN: llvm-dwarfdump -debug-line=0 %t-reserved.o 2> %t-reserved-off-first.err | FileCheck %s --check-prefixes=FIRST,NOLATER
+# RUN: llvm-dwarfdump -debug-line=0 %t-reserved.o 2> %t-reserved-off-first.err \
+# RUN:  | FileCheck %s --check-prefixes=FIRST,NOLATER
 # RUN: FileCheck %s --input-file=%t-reserved-off-first.err --check-prefix=RESERVED
 
 # Stop looking for the specified unit, if a fatally-bad prologue is detected.
-# RUN: llvm-dwarfdump -debug-line=0x4b %t-reserved.o 2> %t-reserved-off-last.err | FileCheck %s --check-prefixes=NOFIRST,NOLATER
+# RUN: llvm-dwarfdump -debug-line=0x4b %t-reserved.o 2> %t-reserved-off-last.err \
+# RUN:   | FileCheck %s --check-prefixes=NOFIRST,NOLATER
 # RUN: FileCheck %s --input-file=%t-reserved-off-last.err --check-prefix=RESERVED
 
 # RUN: llvm-mc -triple x86_64-pc-linux %S/Inputs/debug_line_malformed.s -filetype=obj -o %t-malformed.o
-# RUN: llvm-dwarfdump -debug-line %t-malformed.o 2> %t-malformed.err | FileCheck %s --check-prefixes=FIRST,NONFATAL
+# RUN: llvm-dwarfdump -debug-line %t-malformed.o 2> %t-malformed.err \
+# RUN:   | FileCheck %s --check-prefixes=FIRST,NONFATAL,LAST
 # RUN: FileCheck %s --input-file=%t-malformed.err --check-prefixes=ALL,OTHER
-# RUN: llvm-dwarfdump -debug-line %t-malformed.o -verbose 2> %t-malformed-verbose.err | FileCheck %s --check-prefixes=FIRST,NONFATAL
+# RUN: llvm-dwarfdump -debug-line %t-malformed.o -verbose 2> %t-malformed-verbose.err \
+# RUN:   | FileCheck %s --check-prefixes=FIRST,NONFATAL,LAST
 # RUN: FileCheck %s --input-file=%t-malformed-verbose.err --check-prefixes=ALL,OTHER
 
-# RUN: llvm-dwarfdump -debug-line=0 %t-malformed.o 2> %t-malformed-off-first.err | FileCheck %s --check-prefixes=FIRST,NOLATER
+# 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=0x271 %t-malformed.o 2> %t-malformed-off-last.err | FileCheck %s --check-prefixes=LASTONLY
+# RUN: llvm-dwarfdump -debug-line=0x2f8 %t-malformed.o 2> %t-malformed-off-last.err \
+# RUN:   | FileCheck %s --check-prefixes=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[{{.*}}]
 # NOLATER-NOT: end_sequence
 
-# For fatal issues, the following table(s) should not be dumped.
+## For fatal issues, the following table(s) should not be dumped.
 # FATAL: debug_line[0x00000048]
 # FATAL-NEXT: Line table prologue
 # FATAL-NEXT: total_length: 0xfffffffe
 # FATAL-NOT: debug_line
 
-# For non-fatal prologue issues, the table prologue should be dumped, and any subsequent tables should also be.
+## For non-fatal issues, the table data should be dumped.
+## Case 1: Version 0 table
 # NONFATAL: debug_line[0x00000048]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL-NOT: Address
+
+## Case 2: Version 1 table
 # NONFATAL: debug_line[0x0000004e]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL-NOT: Address
+
+## Case 3: Malformed directory format with no path component.
 # NONFATAL: debug_line[0x00000054]
 # NONFATAL-NEXT: Line table prologue
-# NONFATAL-NOT: Address
-# NONFATAL: debug_line[0x00000073]
+# NONFATAL-NOT: include_directories
+# NONFATAL-NOT: file_names
+# NONFATAL: 0x8877665544332211 {{.*}} end_sequence
+
+## Case 4: Prologue with length shorter than parsed.
+# NONFATAL: debug_line[0x00000081]
+# NONFATAL-NEXT: Line table prologue
+# NONFATAL:      file_names[  2]:
+# NONFATAL-NEXT:            name: "file2"
+# NONFATAL-NEXT:       dir_index: 1
+# NONFATAL-NEXT:        mod_time: 0x00000002
+# NONFATAL-NEXT:          length: 0x00000003
+# NONFATAL: 0x1122334455667788 {{.*}} end_sequence
+
+## Case 5: Prologue with length greater than parsed.
+# NONFATAL: debug_line[0x000000c8]
+# NONFATAL-NEXT: Line table prologue
+# NONFATAL:      file_names[  2]:
+# NONFATAL-NEXT:            name: "file2"
+# NONFATAL-NEXT:       dir_index: 1
+# NONFATAL-NEXT:        mod_time: 0x00000002
+# NONFATAL-NEXT:          length: 0x00000003
+# NONFATAL-NOT:  file_names
+# NONFATAL: 0x1111222233334444 {{.*}} is_stmt end_sequence
+
+## Case 6: Extended opcodes with incorrect lengths versus expected.
+# NONFATAL: debug_line[0x00000111]
 # NONFATAL-NEXT: Line table prologue
-# NONFATAL-NOT: Address
-# NONFATAL: debug_line[0x000000ad]
+# NONFATAL: 0x00000000abbadaba {{.*}} end_sequence
+# NONFATAL: 0x00000000babb1e45 {{.*}} 10 is_stmt end_sequence{{$}}
+
+## Case 7: No end of sequence.
+# NONFATAL: debug_line[0x0000016c]
 # NONFATAL-NEXT: Line table prologue
-# NONFATAL-NOT: Address
-# NONFATAL: debug_line[0x000000e7]
-# Dumping prints the line table prologue and any valid operations up to the point causing the problem.
+# NONFATAL: 0x00000000deadfade {{.*}} is_stmt
+# NONFATAL-NOT: end_sequence
+
+## Case 8: Very short prologue length for V5 (ends during parameters).
+# NONFATAL: debug_line[0x000001b2]
 # NONFATAL-NEXT: Line table prologue
-# NONFATAL: 0x00000000abbadaba {{.*}} end_sequence
-# NONFATAL-NOT: is_stmt
+# NONFATAL:      standard_opcode_lengths[DW_LNS_set_isa] = 1
+# NONFATAL-NEXT: include_directories[  0] = "/tmp"
+# NONFATAL-NEXT: file_names[  0]:
+# NONFATAL-NEXT:            name: "a.c"
+# NONFATAL-NEXT:       dir_index: 1
+# NONFATAL: 0x0000babb1ebabb1e {{.*}} end_sequence
 
-# For minor issues, we can dump the table.
-# NONFATAL: debug_line[0x0000013d]
+## Case 9: V5 prologue ends during file table.
+# NONFATAL: debug_line[0x000001f2]
 # NONFATAL-NEXT: Line table prologue
-# NONFATAL-NOT: debug_line[{{.*}}]
-# NONFATAL: 0x00000000deadfade {{.*}}
-# NONFATAL: debug_line[0x00000183]
-# NONFATAL-NEXT: Line table prologue
-# NONFATAL: debug_line[0x00000271]
-# NONFATAL-NOT: debug_line[{{.*}}]
-# NONFATAL: 0x00000000cafebabe {{.*}} end_sequence
-# NONFATAL-NOT: debug_line[{{.*}}]
-
-# LASTONLY-NOT: debug_line[{{.*}}]
-# LASTONLY: debug_line[0x00000271]
-# LASTONLY: 0x00000000cafebabe {{.*}} end_sequence
+# NONFATAL:      file_names[  0]:
+# NONFATAL-NEXT:            name: "a.c"
+# NONFATAL-NEXT:       dir_index: 1
+# NONFATAL: 0x00000ab4acadab4a {{.*}} end_sequence
 
-# RESERVED: warning: parsing line table prologue at offset 0x00000048 unsupported reserved unit length found of value 0xfffffffe
+## Case 10: V5 prologue ends during directory table.
+# NONFATAL: debug_line[0x00000232]
+# NONFATAL-NEXT: Line table prologue
+# NONFATAL:      include_directories[  0] = "/tmp"
+# NONFATAL-NEXT: file_names[  0]:
+# NONFATAL-NEXT:            name: "a.c"
+# NONFATAL-NEXT:       dir_index: 1
+# NONFATAL: 0x4444333322221111 {{.*}} end_sequence
 
-# MD5: warning: parsing line table prologue at 0x00000000 found an invalid directory or file table description at 0x0000003b
-# MD5-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
+## Case 11: V5 invalid MD5 hash form when there is still data to be read.
+# NONFATAL: debug_line[0x00000272]
+# NONFATAL-NEXT: Line table prologue
+# NONFATAL: 0x1234123412341234 {{.*}} is_stmt end_sequence
+
+## Case 12: V5 invalid MD5 hash form when data beyond the prologue length has
+## been read before the MD5 problem is identified.
+# NONFATAL: debug_line[0x000002b5]
+# NONFATAL-NEXT: Line table prologue
+# NONFATAL: 0x4321432143214321 {{.*}} is_stmt epilogue_begin end_sequence
+
+# LAST: debug_line[0x000002f8]
+# 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
-# FIXME - The latter offset in the next line should be 0xad. The filename parsing code does not notice a missing terminating byte.
-# ALL-NEXT: warning: parsing line table prologue at 0x00000073 should have ended at 0x000000ab but it ended at 0x000000ac
-# ALL-NEXT: warning: parsing line table prologue at 0x000000ad should have ended at 0x000000e8 but it ended at 0x000000e7
-# OTHER-NEXT: warning: unexpected line op length at offset 0x0000012e expected 0x02 found 0x01
+# 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 is not terminated!
-# ALL-NEXT: warning: parsing line table prologue at 0x00000183 found an invalid directory or file table description at 0x000001a2
-# ALL-NEXT: warning: failed to parse entry content descriptions at offset 0x000001a2 because offset extends beyond the prologue end at offset 0x0000019e
-# ALL-NEXT: warning: parsing line table prologue at 0x000001be found an invalid directory or file table description at 0x000001eb
-# ALL-NEXT: warning: failed to parse file entry at offset 0x000001eb because offset extends beyond the prologue end at offset 0x000001e9
-# ALL-NEXT: warning: parsing line table prologue at 0x000001f9 found an invalid directory or file table description at 0x0000021b
-# ALL-NEXT: warning: failed to parse directory entry at offset 0x0000021b because offset extends beyond the prologue end at offset 0x0000021b
-# ALL-NEXT: warning: parsing line table prologue at 0x00000234 found an invalid directory or file table description at 0x00000269
+# ALL-NEXT: warning: parsing line table prologue at 0x000001b2 should have ended at 0x000001cd but it ended at 0x000001e4
+# ALL-NEXT: warning: parsing line table prologue at 0x000001f2 should have ended at 0x0000021d but it ended at 0x00000224
+# ALL-NEXT: warning: parsing line table prologue at 0x00000232 should have ended at 0x00000254 but it ended at 0x00000264
+# ALL-NEXT: warning: parsing line table prologue at 0x00000272 found an invalid directory or file table description at 0x000002a6
+# ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
+# ALL-NEXT: warning: parsing line table prologue at 0x000002b5 found an invalid directory or file table description at 0x000002e9
 # ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
+# ALL-NEXT: warning: parsing line table prologue at 0x000002b5 should have ended at 0x000002e0 but it ended at 0x000002e9
 # ALL-NOT:  warning:

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

CommonFixture()
         RecordUnrecoverable(std::bind(&CommonFixture::recordUnrecoverable, this,
                                       std::placeholders::_1)){};
 
   ~CommonFixture() {
     EXPECT_FALSE(Recoverable);
     EXPECT_FALSE(Unrecoverable);
   }
 
-  bool setupGenerator(uint16_t Version = 4) {
-    Triple T = getDefaultTargetTripleForAddrSize(8);
+  bool setupGenerator(uint16_t Version = 4, uint8_t AddrSize = 8) {
+    AddressSize = AddrSize;
+    Triple T =
+        getDefaultTargetTripleForAddrSize(AddressSize == 0 ? 8 : AddressSize);
     if (!isConfigurationSupported(T))
       return false;
     auto ExpectedGenerator = Generator::create(T, Version);
     if (ExpectedGenerator)
       Gen.reset(ExpectedGenerator->release());
     return true;
   }
 
   void generate() {
     Context = createContext();
     assert(Context != nullptr && "test state is not valid");
     const DWARFObject &Obj = Context->getDWARFObj();
+    uint8_t TargetAddrSize = AddressSize == 0 ? 8 : AddressSize;
     LineData = DWARFDataExtractor(
         Obj, Obj.getLineSection(),
-        getDefaultTargetTripleForAddrSize(8).isLittleEndian(), 8);
+        getDefaultTargetTripleForAddrSize(TargetAddrSize).isLittleEndian(),
+        AddressSize);
   }
 
   std::unique_ptr<DWARFContext> createContext() {
     if (!Gen)
       return nullptr;
     StringRef FileBytes = Gen->generate();
     MemoryBufferRef FileBuffer(FileBytes, "dwarf");
     auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
void checkError(ArrayRef<StringRef> ExpectedMsgs, Error Err) {
     EXPECT_EQ(WhichMsg, ExpectedMsgs.size());
     EXPECT_FALSE(Remaining);
   }
 
   void checkError(StringRef ExpectedMsg, Error Err) {
     checkError(ArrayRef<StringRef>{ExpectedMsg}, std::move(Err));
   }
 
-  void checkGetOrParseLineTableEmitsError(StringRef ExpectedMsg,
+  void checkGetOrParseLineTableEmitsFatalError(StringRef ExpectedMsg,
                                                uint64_t Offset = 0) {
     auto ExpectedLineTable = Line.getOrParseLineTable(
         LineData, Offset, *Context, nullptr, RecordRecoverable);
     EXPECT_FALSE(ExpectedLineTable);
     EXPECT_FALSE(Recoverable);
 
     checkError(ExpectedMsg, ExpectedLineTable.takeError());
   }
 
-  void checkGetOrParseLineTableEmitsError(ArrayRef<StringRef> ExpectedMsgs,
+  void checkGetOrParseLineTableEmitsFatalError(ArrayRef<StringRef> ExpectedMsgs,
                                                uint64_t Offset = 0) {
     auto ExpectedLineTable = Line.getOrParseLineTable(
         LineData, Offset, *Context, nullptr, RecordRecoverable);
     EXPECT_FALSE(ExpectedLineTable);
     EXPECT_FALSE(Recoverable);
 
     checkError(ExpectedMsgs, ExpectedLineTable.takeError());
   }
 
+  uint8_t AddressSize;
   std::unique_ptr<Generator> Gen;
   std::unique_ptr<DWARFContext> Context;
   DWARFDataExtractor LineData;
   DWARFDebugLine Line;
   Error Recoverable;
   std::function<void(Error)> RecordRecoverable;
   Error Unrecoverable;
   std::function<void(Error)> RecordUnrecoverable;
void checkDefaultPrologue(uint16_t Version, DwarfFormat Format,
   EXPECT_STREQ(*Prologue.FileNames[0].Name.getAsCString(), "a file");
 }
 
 TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffset) {
   if (!setupGenerator())
     return;
   generate();
 
-  checkGetOrParseLineTableEmitsError(
+  checkGetOrParseLineTableEmitsFatalError(
       "offset 0x00000000 is not a valid debug line section offset", 0);
   // Repeat to show that an error is reported each time.
-  checkGetOrParseLineTableEmitsError(
+  checkGetOrParseLineTableEmitsFatalError(
       "offset 0x00000000 is not a valid debug line section offset", 0);
   // Show that an error is reported for later offsets too.
-  checkGetOrParseLineTableEmitsError(
+  checkGetOrParseLineTableEmitsFatalError(
       "offset 0x00000001 is not a valid debug line section offset", 1);
 }
 
 TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffsetAfterData) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0, LineTable::Byte}});
 
   generate();
 
-  checkGetOrParseLineTableEmitsError(
+  checkGetOrParseLineTableEmitsFatalError(
       "offset 0x00000001 is not a valid debug line section offset", 1);
 }
 
 TEST_P(DebugLineParameterisedFixture, GetOrParseLineTableValidTable) {
   if (!setupGenerator(Version))
     return;
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
TEST_F(DebugLineBasicFixture, ErrorForReservedLength) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
 
   generate();
 
-  checkGetOrParseLineTableEmitsError(
+  checkGetOrParseLineTableEmitsFatalError(
       "parsing line table prologue at offset 0x00000000 unsupported reserved "
       "unit length found of value 0xfffffff0");
 }
 
 TEST_F(DebugLineBasicFixture, ErrorForLowVersion) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue(
       {{LineTable::Half, LineTable::Long}, {1, LineTable::Half}});
 
   generate();
 
-  checkGetOrParseLineTableEmitsError("parsing line table prologue at offset "
-                                     "0x00000000 found unsupported version "
-                                     "0x01");
+  checkGetOrParseLineTableEmitsFatalError(
+      "parsing line table prologue at offset "
 }
 
 TEST_F(DebugLineBasicFixture, ErrorForInvalidV5IncludeDirTable) {
   if (!setupGenerator(5))
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({
LT.setCustomPrologue({
                              // zero).
       {0, LineTable::ULEB},  // directories count
       {0, LineTable::Byte},  // file name entry format count
       {0, LineTable::ULEB}   // file name entry count
   });
 
   generate();
 
-  checkGetOrParseLineTableEmitsError(
+  auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
+                                                    nullptr, RecordRecoverable);
+  EXPECT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
+
+  checkError(
       {"parsing line table prologue at 0x00000000 found an invalid directory "
        "or file table description at 0x00000014",
-       "failed to parse entry content descriptions because no path was found"});
+       "failed to parse entry content descriptions because no path was found"},
+      std::move(Recoverable));
 }
 
 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);
   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);
+
   uint64_t ExpectedEnd =
       Prologue.TotalLength + 1 + Prologue.sizeofTotalLength();
-  checkGetOrParseLineTableEmitsError(
+  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());
+          .str(),
+      std::move(Recoverable));
 }
 
 TEST_P(DebugLineParameterisedFixture, ErrorForTooShortPrologueLength) {
   if (!setupGenerator(Version))
     return;
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);
   DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
   // FIXME: Ideally, we'd test for 1 less than expected, but the code does not
   // currently fail if missing only the terminator of a v2-4 file table.
   if (Version < 5)
     Prologue.PrologueLength -= 2;
   else
     Prologue.PrologueLength -= 1;
   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.
+  if (Version < 5)
+    Result.Prologue.PrologueLength += 2;
+  else
+    Result.Prologue.PrologueLength += 1;
+  checkDefaultPrologue(Version, Format, Result.Prologue, 0);
+
   uint64_t ExpectedEnd =
       Prologue.TotalLength - 1 + Prologue.sizeofTotalLength();
   if (Version < 5)
     --ExpectedEnd;
-  checkGetOrParseLineTableEmitsError(
+  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());
+          .str(),
+      std::move(Recoverable));
 }
 
 INSTANTIATE_TEST_CASE_P(
     LineTableTestParams, DebugLineParameterisedFixture,
     Values(std::make_pair(
                2, DWARF32), // Test lower-bound of v2-3 fields and DWARF32.
            std::make_pair(3, DWARF32), // Test upper-bound of v2-3 fields.
            std::make_pair(4, DWARF64), // Test v4 fields and DWARF64.
            std::make_pair(5, DWARF32), std::make_pair(5, DWARF64)), );
 
-TEST_F(DebugLineBasicFixture, ErrorForInvalidExtendedOpcodeLength) {
+TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthSmallerThanExpected) {
+  if (!setupGenerator())
+    return;
+
+  LineTable &LT = Gen->addLineTable();
+  LT.addByte(0xaa);
+  // The Length should be 1 + sizeof(ULEB) for a set discriminator opcode.
+  // If the parser were to continue assuming a length of 1, the operand would be
+  // treated as a negate_stmt.
+  LT.addExtendedOpcode(1, DW_LNE_set_discriminator,
+                       {{DW_LNS_negate_stmt, LineTable::ULEB}});
+  LT.addByte(0xbb);
+  LT.addStandardOpcode(DW_LNS_const_add_pc, {});
+  LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+
+  generate();
+
+  auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
+                                                    nullptr, RecordRecoverable);
+  checkError(
+      "unexpected line op length at offset 0x00000031 expected 0x01 found 0x02",
+      std::move(Recoverable));
+  ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
+  ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 3u);
+  EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
+  EXPECT_EQ((*ExpectedLineTable)->Rows[1].IsStmt, 1u);
+}
+
+TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthLargerThanExpected) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
+  LT.addByte(0xaa);
+  LT.addStandardOpcode(DW_LNS_const_add_pc, {});
   // The Length should be 1 for an end sequence opcode.
   LT.addExtendedOpcode(2, DW_LNE_end_sequence, {});
+  // The negate statement opcode will be skipped.
+  LT.addStandardOpcode(DW_LNS_negate_stmt, {});
+  LT.addByte(0xbb);
+  LT.addStandardOpcode(DW_LNS_const_add_pc, {});
+  LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
 
   generate();
 
-  checkGetOrParseLineTableEmitsError("unexpected line op length at offset "
-                                     "0x00000030 expected 0x02 found 0x01");
+  auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
+                                                    nullptr, RecordRecoverable);
+  checkError(
+      "unexpected line op length at offset 0x00000032 expected 0x02 found 0x01",
+      std::move(Recoverable));
+  ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
+  ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 4u);
+  EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 2u);
+  ASSERT_EQ((*ExpectedLineTable)->Sequences[1].FirstRowIndex, 2u);
+  EXPECT_EQ((*ExpectedLineTable)->Rows[2].IsStmt, 1u);
 }
 
 TEST_F(DebugLineBasicFixture, ErrorForMismatchedAddressSize) {
-  if (!setupGenerator())
+  if (!setupGenerator(4, 8))
     return;
 
   LineTable &LT = Gen->addLineTable();
   // The line data extractor expects size 8 (Quad) addresses.
-  LT.addExtendedOpcode(5, DW_LNE_set_address, {{0x11223344, LineTable::Long}});
+  uint64_t Addr1 = 0x11223344;
+  LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}});
   LT.addStandardOpcode(DW_LNS_copy, {});
-  LT.addByte(0xaa);
+  // Show that the expected address size is unchanged, so later valid lines
+  // don't cause a problem.
+  uint64_t Addr2 = 0x1122334455667788;
+  LT.addExtendedOpcode(9, DW_LNE_set_address, {{Addr2, LineTable::Quad}});
+  LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+
+  generate();
+
+  auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
+                                                    nullptr, RecordRecoverable);
+  checkError(
+      "mismatching address size at offset 0x00000030 expected 0x08 found 0x04",
+      std::move(Recoverable));
+  ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
+  ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u);
+  EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
+  EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1);
+  EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2);
+}
+
+TEST_F(DebugLineBasicFixture,
+       ErrorForMismatchedAddressSizeUnsetInitialAddress) {
+  if (!setupGenerator(4, 0))
+    return;
+
+  LineTable &LT = Gen->addLineTable();
+  uint64_t Addr1 = 0x11223344;
+  LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}});
+  LT.addStandardOpcode(DW_LNS_copy, {});
+  uint64_t Addr2 = 0x1122334455667788;
+  LT.addExtendedOpcode(9, DW_LNE_set_address, {{Addr2, LineTable::Quad}});
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
 
   generate();
 
-  checkGetOrParseLineTableEmitsError(
-      "mismatching address size at offset 0x00000030 expected 0x08 found 0x04");
+  auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
+                                                    nullptr, RecordRecoverable);
+  checkError(
+      "mismatching address size at offset 0x00000038 expected 0x04 found 0x08",
+      std::move(Recoverable));
+  ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
+  ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u);
+  EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
+  EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1);
+  EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2);
 }
 
 TEST_F(DebugLineBasicFixture, CallbackUsedForUnterminatedSequence) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.addExtendedOpcode(9, DW_LNE_set_address,
TEST_F(DebugLineBasicFixture, ParserSkipsCorrectly) {
   if (!setupGenerator())
     return;
 
   DWARFDebugLine::SectionParser Parser = setupParser();
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   ASSERT_FALSE(Parser.done());
 
-  Parser.skip(RecordUnrecoverable);
+  Parser.skip(RecordRecoverable, RecordUnrecoverable);
   EXPECT_EQ(Parser.getOffset(), 62u);
   ASSERT_FALSE(Parser.done());
 
-  Parser.skip(RecordUnrecoverable);
+  Parser.skip(RecordRecoverable, RecordUnrecoverable);
   EXPECT_EQ(Parser.getOffset(), 136u);
   EXPECT_TRUE(Parser.done());
 
+  EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
 }
 
 TEST_F(DebugLineBasicFixture, ParserAlwaysDoneForEmptySection) {
   if (!setupGenerator())
     return;
 
   generate();
if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable();
   LT.setCustomPrologue({{0xfffffff0, LineTable::Long}});
   Gen->addLineTable();
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs);
-  Parser.skip(RecordUnrecoverable);
+  Parser.skip(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_EQ(Parser.getOffset(), 4u);
   EXPECT_TRUE(Parser.done());
+  EXPECT_FALSE(Recoverable);
 
   checkError("parsing line table prologue at offset 0x00000000 unsupported "
              "reserved unit length found of value 0xfffffff0",
              std::move(Unrecoverable));
 }
 
 TEST_F(DebugLineBasicFixture, ParserReportsFirstErrorInEachTableWhenParsing) {
   if (!setupGenerator())
TEST_F(DebugLineBasicFixture, ParserReportsNonPrologueProblemsWhenParsing) {
   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(Recoverable);
+  EXPECT_FALSE(Unrecoverable);
   ASSERT_FALSE(Parser.done());
   checkError(
       "unexpected line op length at offset 0x00000030 expected 0x42 found 0x01",
-      std::move(Unrecoverable));
+      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 is not terminated!",
              std::move(Recoverable));
   EXPECT_FALSE(Unrecoverable);
 }
 
 TEST_F(DebugLineBasicFixture,
        ParserReportsPrologueErrorsInEachTableWhenSkipping) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}});
   LineTable &LT2 = Gen->addLineTable(DWARF32);
   LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}});
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs);
-  Parser.skip(RecordUnrecoverable);
+  Parser.skip(RecordRecoverable, RecordUnrecoverable);
   ASSERT_FALSE(Parser.done());
-  Parser.skip(RecordUnrecoverable);
+  Parser.skip(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_TRUE(Parser.done());
+  EXPECT_FALSE(Recoverable);
 
   checkError({"parsing line table prologue at offset 0x00000000 found "
               "unsupported version 0x00",
               "parsing line table prologue at offset 0x00000006 found "
               "unsupported version 0x01"},
              std::move(Unrecoverable));
 }
 
 TEST_F(DebugLineBasicFixture, ParserIgnoresNonPrologueErrorsWhenSkipping) {
   if (!setupGenerator())
     return;
 
   LineTable &LT = Gen->addLineTable(DWARF32);
   LT.addExtendedOpcode(42, DW_LNE_end_sequence, {});
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs);
-  Parser.skip(RecordUnrecoverable);
+  Parser.skip(RecordRecoverable, RecordUnrecoverable);
 
   EXPECT_TRUE(Parser.done());
+  EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
 }
 
 TEST_F(DebugLineBasicFixture, ParserPrintsStandardOpcodesWhenRequested) {
   if (!setupGenerator())
     return;
 
   using ValLen = dwarfgen::LineTable::ValueAndLength;