[DWARF] Rework debug line parsing to use llvm::Error

[jhenderson]

Summary

The .debug_line parser previously reported errors by printing to stderr and return false. This is not particularly helpful for clients of the library code, as it prevents them from handling the errors in a manner based on the calling context. This change switches to using llvm::Error to indicate what problems were detected during parsing, and has updated clients to handle the errors in a location-specific manner. In general, this means that they continue to do the same thing to external users. Below, I have outlined what the known behaviour changes are, relating to this change.

There are three levels of "errors" in the new error mechanism, to broadly distinguish between different fail states of the parser, since not every failure will prevent parsing of the unit, or of subsequent unit. Fatal errors represent errors that prevent reading the unit length field. If this happens, it will be impossible to know where the next unit starts, so this will prevent further parsing of both the current unit and any subsequent ones. Major errors represent errors that prevent reading the remainder of the table, e.g. because
the version is unsupported. Minor errors represent problems with parsing that do not prevent attempting to continue reading the table. The only example of this currently is when the last sequence of a unit is unterminated. However, I think it would be good to change the handling of unrecognised opcodes to report as minor errors as well, rather than just printing to the stream if --verbose is used (this would be a subsequent change however).

I have substantially extended the DwarfGenerator to be able to handle custom-crafted .debug_line sections, allowing for comprehensive unit-testing of the parser code. For now, I am just adding unit tests to cover the basic error reporting, and positive cases, and do not currently intend to test every part of the parser, although the framework should be sufficient to do so at a later point. Note that the current diff is still a work-in-progress in the unit tests - I am happy with most of what is there, but I intend to add further tests for basic DWARF 5 positive cases, and for each of the different possible errors that can be reported. I will update the diff once these are complete, but I wanted to put the current state up so that people can start commenting on it.

Known behaviour changes:

• The dump function in DWARFContext now does not attempt to read subsequent tables when searching for a specific offset, if there was a fatal error.
• The dump function now uses the severity of the error to determine if subsequent units should be read or not. If a major error is detected, the table is skipped, but subsequent ones are read, making the assumption that the unit length field is valid.
• getOrParseLineTable now returns a useful Error if an invalid offset is encountered, rather than simply a nullptr.
• getOrParseLineTable now returns both the Error returned from LineTable::parse and the line table, if only Minor-level errors are encountered.
• The parse functions no longer use fprintf(stderr,...) to report errors, meaning that LLD will now correctly print errors, rather than them sometimes not being flushed, or being interleaved with other errors (see also the forthcoming LLD review).
• The existing parse error messages have been updated to not specifically include "warning" in their message, allowing consumers to determine what severity the problem is.
• If the line table version field appears to have a value less than 2, an informative error is returned, instead of just false.
• If the line table unit length field uses a reserved value, an informative error is returned, instead of just false.

As a helper for the generator code, I have re-added EmitInt64 to the AsmPrinter code. This previously existed, but was removed way back in r100296, presumably because it was dead at the time. A quick review of LLVM code suggests that there are several places that could do with this function, instead of using EmitIntValue(..., 8).

This change also requires a change to LLD. I will post a separate review for this shortly, since I don't know how to reliably create a review for both repositories simultaneously.

I'm conscious that this is quite a large change, so if anybody has any suggestions on how to usefully break it up, please let me know.

[labath]

I am quite new to this part of llvm, so I'll just sit back and learn. I'll just say that a similar error classification would be very useful for the debug_names parser (which I am working on now, and I have noticed the inability to signal that just one of the name indexes is corrupt) and probably a lot of other debug info parsers, so I welcome this effort (though I'm not entirely sure that your usage of llvm::Error is completely idiomatic here).

include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

68

Drop the &&. This makes it clear that the function will clear the error (whereas previously it could just ignore them and leave the caller with an uncleared error).

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

42–43

Why should we ever have an error with severity "none"?

[jhenderson]

In D44382#1034669, @labath wrote:

(though I'm not entirely sure that your usage of llvm::Error is completely idiomatic here).

Thanks for the comments. I am fairly new to llvm::Error myself, so I completely agree that this is probably a little unusual. I did consider the alternative which is to have a separate ErrorInfo class for each of the different severities, but that didn't fit particularly well in some situations, e.g. when treating Major amd Fatal errors the same, but distinct from Minor. I'm certainly open to suggestions for alternatives.

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

42–43

You shouldn't (and I'm tempted to put an unreachable assert here). The problem is that we need a default value that indicates no error, so that a caller doesn't also have to check against Error::success().

[jhenderson]

This change also requires a change to LLD. I will post a separate review for this shortly, since I don't know how to reliably create a review for both repositories simultaneously.

Review posted as D44388.

[JDevlieghere]

Hi James,

First off, thanks for working on this! Unfortunately I didn't get around to reviewing this today. As a general note, like Pavel already said, this isn't really idiomatic when it comes to the Error class. The None severity doesn't make sense (you could always return an Optional<Severity> where necessary) but I don't have a good solution in mind when it comes to surfacing the other kind of errors. I'll have a more in-depth look tomorrow to better understand the constraints.

[• rafael]

James Henderson via Phabricator via llvm-commits
<[e-mail]> writes:

jhenderson created this revision.
jhenderson added reviewers: probinson, dblaikie, JDevlieghere, aprantl, labath.

The .debug_line parser previously reported errors by printing to stderr and return false. This is not particularly helpful for clients of the library code, as it prevents them from handling the errors in a manner based on the calling context. This change switches to using llvm::Error to indicate what problems were detected during parsing, and has updated clients to handle the errors in a location-specific manner. In general, this means that they continue to do the same thing to external users. Below, I have outlined what the known behaviour changes are, relating to this change.

There are three levels of "errors" in the new error mechanism, to broadly distinguish between different fail states of the parser, since not every failure will prevent parsing of the unit, or of subsequent unit. Fatal errors represent errors that prevent reading the unit length field. If this happens, it will be impossible to know where the next unit starts, so this will prevent further parsing of both the current unit and any subsequent ones. Major errors represent errors that prevent reading the remainder of the table, e.g. because
the version is unsupported. Minor errors represent problems with parsing that do not prevent attempting to continue reading the table. The only example of this currently is when the last sequence of a unit is unterminated. However, I think it would be good to change the handling of unrecognised opcodes to report as minor errors as well, rather than just printing to the stream if --verbose is used (this would be a subsequent change however).

The main advantaged of using Expected is that it is not possible to
access an invalid object.

If possible I think it would be better to reserve Error/Expected for "it
was not possible to produce the requested result" and have some
logging/diagnostics/callback system for things that can be ignored.

For example, getOrParseLineTable could return Expected<const LineTable
*> and take a callback for non fatal issues:

if (Error = Callback(DebugLineDiag::Minor,

                                "last sequence in debug line table is not"
                                " terminated!"))
return Error;

And it is up to the callback whether it wants getOrParseLineTable to fail.

Alternatively it could return Expected<std::pair<const LineTable *, Warnings>>.

Cheers,
Rafael

[jhenderson]

Dropped unnecessary '&&' usage. Replaced use of "None" Severity with an Optional. Added remaining missing unit tests, fixed a number of issues in the test framework, and refactored some of the common test code to reduce code duplication. Also add paramterised test instantations for different DWARF formats.

I haven't yet attempted in this diff to look at how to make the code more idiomatic. I'll do that next, but I might put it up as an alternative review, so that we can evaluate both approaches simultaneously. One idea I had was rather than to use different Severities associated with each individual DebugLineError instance, to have different ErrorInfo classes for the different severities (e.g. have a DebugLineFatalError, DebugLineMajorError, and DebugLineMinorError). The handling code could still use a Severity enum or similar to report back, or I could just change how the handling code works, to take in a callback, similar to what was suggested. Thoughts?

[jhenderson]

I think D44560 is my preferred approach overall. Abandoning.

include/llvm/CodeGen/AsmPrinter.h

public:
   void EmitInt8(int Value) const;
 
   /// Emit a short directive and value.
   void EmitInt16(int Value) const;
 
   /// Emit a long directive and value.
   void EmitInt32(int Value) const;
 
+  /// Emit a long long directive and value.
+  void EmitInt64(uint64_t Value) const;
+
   /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
   /// is specified by Size and Hi/Lo specify the labels.  This implicitly uses
   /// .set if it is available.
   void EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
                            unsigned Size) const;
 
   /// Emit something like ".uleb128 Hi-Lo".
   void EmitLabelDifferenceAsULEB128(const MCSymbol *Hi,

include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

 #include <string>
 #include <vector>
 
 namespace llvm {
 
 class DWARFUnit;
 class raw_ostream;
 
+class DebugLineError : public ErrorInfo<DebugLineError> {
+public:
+  static char ID;
+
+  enum Severity {
+    // For issues that do not prevent parsing the unit.
+    Minor,
+    // For errors that prevent reading that unit, but not later units. In such
+    // a situation, at least the TotalLength field of the corresponding
+    // Prologue must be set.
+    Major,
+    // For errors that prevent parsing subsequent units.
+    Fatal
+  };
+
+  DebugLineError(Severity Sev, const Twine &Msg) : Sev(Sev), Msg(Msg.str()) {}
+
+  void log(raw_ostream &OS) const override;
+  std::error_code convertToErrorCode() const override {
+    return inconvertibleErrorCode();
+  }
+
+  Severity getSeverity() const { return Sev; }
+
+private:
+  Severity Sev;
+  std::string Msg;
+};
+
+/// Report any errors and warnings detected during parsing of a debug line
+/// table.
+///
+/// \param ParseErrors The errors returned by a call to LineTable::parse() or
+/// Prologue::parse().
+///
+/// \returns the highest severity reported, or None if no errors were reported.
+Optional<DebugLineError::Severity>
+handleDebugLineParseErrors(Error ParseErrors);
+
 class DWARFDebugLine {
 public:
   struct FileNameEntry {
     FileNameEntry() = default;
 
     DWARFFormValue Name;
     uint64_t DirIdx = 0;
     uint64_t ModTime = 0;
struct Prologue {
     }
 
     int32_t getMaxLineIncrementForSpecialOpcode() const {
       return LineBase + (int8_t)LineRange - 1;
     }
 
     void clear();
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
-    bool parse(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
+    Error parse(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
                 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.
     void postAppend();
struct LineTable {
     bool getFileLineInfoForAddress(uint64_t Address, const char *CompDir,
                                    DILineInfoSpecifier::FileLineInfoKind Kind,
                                    DILineInfo &Result) const;
 
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     void clear();
 
     /// Parse prologue and all rows.
-    bool parse(DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
+    Error parse(DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
                 const DWARFContext &Ctx, const DWARFUnit *U,
                 raw_ostream *OS = nullptr);
 
     using RowVector = std::vector<Row>;
     using RowIter = RowVector::const_iterator;
     using SequenceVector = std::vector<Sequence>;
     using SequenceIter = SequenceVector::const_iterator;
 
     struct Prologue Prologue;
     RowVector Rows;
     SequenceVector Sequences;
 
   private:
     uint32_t findRowInSeq(const DWARFDebugLine::Sequence &Seq,
                           uint64_t Address) const;
-    Optional<StringRef> getSourceByIndex(uint64_t FileIndex,
-                                         DILineInfoSpecifier::FileLineInfoKind Kind) const;
+    Optional<StringRef>
+    getSourceByIndex(uint64_t FileIndex,
   };
 
+  // Not all Errors returned from the line table parse function indicate a
+  // failure to parse the table. This class allows us to return both such errors
+  // and the parsed table at the same time.
+  struct LineTableAndError {
+    const LineTable *Table;
+    Error Err;
+  };
+
   const LineTable *getLineTable(uint32_t Offset) const;
-  const LineTable *getOrParseLineTable(DWARFDataExtractor &DebugLineData,
+  LineTableAndError getOrParseLineTable(DWARFDataExtractor &DebugLineData,
                                         uint32_t Offset, const DWARFContext &C,
                                         const DWARFUnit *U);
 
 private:
   struct ParsingState {
     ParsingState(struct LineTable *LT);
 
     void resetRowAndSequence();
     void appendRowToMatrix(uint32_t Offset);
 

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::EmitInt16(int Value) const {
   OutStreamer->EmitIntValue(Value, 2);
 }
 
 /// EmitInt32 - Emit a long directive and value.
 void AsmPrinter::EmitInt32(int Value) const {
   OutStreamer->EmitIntValue(Value, 4);
 }
 
+/// EmitInt64 - Emit a long long directive and value.
+void AsmPrinter::EmitInt64(uint64_t Value) const {
+  OutStreamer->EmitIntValue(Value, 8);
+}
+
 /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
 /// is specified by Size and Hi/Lo specify the labels. This implicitly uses
 /// .set if it avoids relocations.
 void AsmPrinter::EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
                                      unsigned Size) const {
   OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, Size);
 }
 

lib/DebugInfo/DWARF/DWARFContext.cpp

while (Offset < LineData.getData().size()) {
       auto It = LineToUnit.find(Offset);
       if (It != LineToUnit.end())
         U = It->second;
       LineData.setAddressSize(U ? U->getAddressByteSize() : 0);
       DWARFDebugLine::LineTable LineTable;
       if (DumpOffset && Offset != *DumpOffset) {
         // Find the size of this part of the line table section and skip it.
         unsigned OldOffset = Offset;
-        LineTable.Prologue.parse(LineData, &Offset, *this, U);
+        Error Err = LineTable.Prologue.parse(LineData, &Offset, *this, U);
+        Optional<DebugLineError::Severity> Severity =
+            handleDebugLineParseErrors(std::move(Err));
+        if (Severity && *Severity == DebugLineError::Fatal)
+          break;
         Offset = OldOffset + LineTable.Prologue.TotalLength +
                  LineTable.Prologue.sizeofTotalLength();
         continue;
       }
       // Verbose dumping is done during parsing and not on the intermediate
       // representation.
       OS << "debug_line[" << format("0x%8.8x", Offset) << "]\n";
       unsigned OldOffset = Offset;
       if (DumpOpts.Verbose) {
-        LineTable.parse(LineData, &Offset, *this, U, &OS);
+        Error Err = LineTable.parse(LineData, &Offset, *this, U, &OS);
+        Optional<DebugLineError::Severity> Severity =
+            handleDebugLineParseErrors(std::move(Err));
+        if (Severity && *Severity == DebugLineError::Fatal)
+          break;
       } else {
-        LineTable.parse(LineData, &Offset, *this, U);
+        Error Err = LineTable.parse(LineData, &Offset, *this, U);
+        Optional<DebugLineError::Severity> Severity =
+            handleDebugLineParseErrors(std::move(Err));
+        if (Severity && *Severity == DebugLineError::Fatal)
+          break;
+        if (!Severity || *Severity < DebugLineError::Major)
           LineTable.dump(OS, DIDumpOptions());
       }
-      // Check for unparseable prologue, to avoid infinite loops.
-      if (OldOffset == Offset)
-        break;
+      // If we get here, we can assume that the unit length field is valid, so
+      // use that to move Offset to past the end of the table, in case it wasn't
+      // adjusted automatically by the parser.
+      Offset = OldOffset + LineTable.Prologue.TotalLength +
+               LineTable.Prologue.sizeofTotalLength();
     }
   }
 
   if (shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine,
                  DObj->getLineDWOSection().Data)) {
     LineToUnitMap LineToUnit =
         buildLineToUnitMap(dwo_compile_units(), dwo_type_unit_sections());
     unsigned Offset = 0;
     DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(),
                                 isLittleEndian(), 0);
     while (Offset < LineData.getData().size()) {
       DWARFUnit *U = nullptr;
       auto It = LineToUnit.find(Offset);
       if (It != LineToUnit.end())
         U = It->second;
       DWARFDebugLine::LineTable LineTable;
       unsigned OldOffset = Offset;
-      if (!LineTable.Prologue.parse(LineData, &Offset, *this, U))
+      Error Err = LineTable.Prologue.parse(LineData, &Offset, *this, U);
+      Optional<DebugLineError::Severity> Severity =
+          handleDebugLineParseErrors(std::move(Err));
+      if (Severity && *Severity == DebugLineError::Fatal)
         break;
-      if (!DumpOffset || OldOffset == *DumpOffset)
+      if ((!Severity || *Severity < DebugLineError::Major) &&
+          (!DumpOffset || OldOffset == *DumpOffset))
         LineTable.dump(OS, DumpOpts);
+      Offset = OldOffset + LineTable.Prologue.TotalLength +
+               LineTable.Prologue.sizeofTotalLength();
     }
   }
 
   if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex,
                  DObj->getCUIndexSection())) {
     getCUIndex().dump(OS);
   }
 
DWARFContext::getLineTableForUnit(DWARFUnit *U) {
 
   // Make sure the offset is good before we try to parse.
   if (stmtOffset >= U->getLineSection().Data.size())
     return nullptr;
 
   // We have to parse it first.
   DWARFDataExtractor lineData(*DObj, U->getLineSection(), isLittleEndian(),
                               U->getAddressByteSize());
-  return Line->getOrParseLineTable(lineData, stmtOffset, *this, U);
+
+  auto LineTableAndErr =
+      Line->getOrParseLineTable(lineData, stmtOffset, *this, U);
+  handleDebugLineParseErrors(std::move(LineTableAndErr.Err));
+  return LineTableAndErr.Table;
 }
 
 void DWARFContext::parseCompileUnits() {
   CUs.parse(*this, DObj->getInfoSection());
 }
 
 void DWARFContext::parseTypeUnits() {
   if (!TUs.empty())

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <cstdio>
 #include <utility>
 
 using namespace llvm;
 using namespace dwarf;
 
 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
 
+char DebugLineError::ID = 0;
+
+void DebugLineError::log(raw_ostream &OS) const { OS << Msg << "\n"; }
+
+Optional<DebugLineError::Severity>
+llvm::handleDebugLineParseErrors(Error ParseErrors) {
+  Optional<DebugLineError::Severity> HighestSeverity;
+  handleAllErrors(std::move(ParseErrors),
+                  [&](DebugLineError &Info) {
+                    WithColor(errs(), HighlightColor::Warning).get()
+                        << "warning: ";
+                    Info.log(errs());
+                    if (!HighestSeverity)
+                      HighestSeverity = Info.getSeverity();
+                    else
+                      HighestSeverity =
+                          std::max(*HighestSeverity, Info.getSeverity());
+                  },
+                  [&](ErrorInfoBase &Info) {
+                    // Treat unexpected errors the same as fatal ones, since we
+                    // don't know what state the parser is now in.
+                    Info.log(errs());
+                    HighestSeverity = DebugLineError::Fatal;
+                  });
+  return HighestSeverity;
+}
+
 namespace {
 
 struct ContentDescriptor {
   dwarf::LineNumberEntryFormat Type;
   dwarf::Form Form;
 };
 
 using ContentDescriptors = SmallVector<ContentDescriptor, 4>;
for (auto Descriptor : FileDescriptors) {
         break;
       }
     }
     FileNames.push_back(FileEntry);
   }
   return true;
 }
 
-bool DWARFDebugLine::Prologue::parse(const DWARFDataExtractor &DebugLineData,
+template <typename... Ts>
+static Error createError(DebugLineError::Severity Severity, char const *Fmt,
+                         const Ts &... Vals) {
+  std::string Buffer;
+  raw_string_ostream Stream(Buffer);
+  Stream << format(Fmt, Vals...);
+  return make_error<DebugLineError>(Severity, Stream.str());
+}
+
+Error DWARFDebugLine::Prologue::parse(const DWARFDataExtractor &DebugLineData,
                                       uint32_t *OffsetPtr,
                                       const DWARFContext &Ctx,
                                       const DWARFUnit *U) {
   const uint64_t PrologueOffset = *OffsetPtr;
 
   clear();
   TotalLength = DebugLineData.getU32(OffsetPtr);
   if (TotalLength == UINT32_MAX) {
     FormParams.Format = dwarf::DWARF64;
     TotalLength = DebugLineData.getU64(OffsetPtr);
   } else if (TotalLength >= 0xffffff00) {
-    return false;
+    return createError(
+        DebugLineError::Fatal,
+        "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 false;
+    return createError(DebugLineError::Major,
+                       "parsing line table prologue at offset 0x%8.8" PRIx64
+                       " found unsupported version 0x%2.2" PRIx16,
+                       PrologueOffset, getVersion());
 
   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);
   }
for (uint32_t I = 1; I < OpcodeBase; ++I) {
     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
     StandardOpcodeLengths.push_back(OpLen);
   }
 
   if (getVersion() >= 5) {
     if (!parseV5DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
                               FormParams, Ctx, U, ContentTypes,
                               IncludeDirectories, FileNames)) {
-      fprintf(stderr,
-              "warning: parsing line table prologue at 0x%8.8" PRIx64
-              " found an invalid directory or file table description at"
-              " 0x%8.8" PRIx64 "\n", PrologueOffset, (uint64_t)*OffsetPtr);
-      return false;
+      return createError(
+          DebugLineError::Major,
+          "parsing line table prologue at 0x%8.8" PRIx64
+          " 0x%8.8" PRIx64,
+          PrologueOffset, (uint64_t)*OffsetPtr);
     }
   } else
     parseV2DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
                          ContentTypes, IncludeDirectories, FileNames);
 
-  if (*OffsetPtr != EndPrologueOffset) {
-    fprintf(stderr,
-            "warning: parsing line table prologue at 0x%8.8" PRIx64
+  if (*OffsetPtr != EndPrologueOffset)
+    return createError(DebugLineError::Major,
+                       "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 "\n",
+                       " but it ended at 0x%8.8" PRIx64,
                        PrologueOffset, EndPrologueOffset, (uint64_t)*OffsetPtr);
-    return false;
-  }
-  return true;
+  return Error::success();
 }
 
 DWARFDebugLine::Row::Row(bool DefaultIsStmt) { reset(DefaultIsStmt); }
 
 void DWARFDebugLine::Row::postAppend() {
   BasicBlock = false;
   PrologueEnd = false;
   EpilogueBegin = false;

 const DWARFDebugLine::LineTable *
 DWARFDebugLine::getLineTable(uint32_t Offset) const {
   LineTableConstIter Pos = LineTableMap.find(Offset);
   if (Pos != LineTableMap.end())
     return &Pos->second;
   return nullptr;
 }
 
-const DWARFDebugLine::LineTable *
+DWARFDebugLine::LineTableAndError
 DWARFDebugLine::getOrParseLineTable(DWARFDataExtractor &DebugLineData,
                                     uint32_t Offset, const DWARFContext &Ctx,
                                     const DWARFUnit *U) {
   if (!DebugLineData.isValidOffset(Offset))
-    return nullptr;
+    return {nullptr, createError(DebugLineError::Fatal,
+                                 "offset 0x%8.8" PRIx64
+                                 " is not a valid debug line section offset",
+                                 Offset)};
 
   std::pair<LineTableIter, bool> Pos =
       LineTableMap.insert(LineTableMapTy::value_type(Offset, LineTable()));
   LineTable *LT = &Pos.first->second;
   if (Pos.second) {
-    if (!LT->parse(DebugLineData, &Offset, Ctx, U))
-      return nullptr;
-  }
-  return LT;
+    Error Err = LT->parse(DebugLineData, &Offset, Ctx, U);
+    Err = handleErrors(std::move(Err), [&](std::unique_ptr<DebugLineError> E) {
+      if (E->getSeverity() > DebugLineError::Minor)
+        LT = nullptr;
+      return Error(std::move(E));
+    });
+    return {LT, std::move(Err)};
+  }
+  return {LT, Error::success()};
+}
+
+static Error handlePrologueError(Error NewError, Error PreviousErrors,
+                                 bool *ShouldTerminate) {
+  return joinErrors(
+      std::move(PreviousErrors),
+      handleErrors(std::move(NewError), [&](std::unique_ptr<DebugLineError> E) {
+        if (E->getSeverity() > DebugLineError::Minor)
+          *ShouldTerminate = true;
+        return Error(std::move(E));
+      }));
 }
 
-bool DWARFDebugLine::LineTable::parse(DWARFDataExtractor &DebugLineData,
+Error DWARFDebugLine::LineTable::parse(DWARFDataExtractor &DebugLineData,
                                        uint32_t *OffsetPtr,
                                        const DWARFContext &Ctx,
                                        const DWARFUnit *U, raw_ostream *OS) {
   const uint32_t DebugLineOffset = *OffsetPtr;
 
   clear();
 
-  if (!Prologue.parse(DebugLineData, OffsetPtr, Ctx, U)) {
-    // Restore our offset and return false to indicate failure!
-    *OffsetPtr = DebugLineOffset;
-    return false;
+  Error Errors = Error::success();
+  if (Error PrologueErr = Prologue.parse(DebugLineData, OffsetPtr, Ctx, U)) {
+    bool TerminateParsing = false;
+    Errors = handlePrologueError(std::move(PrologueErr), std::move(Errors),
+                                 &TerminateParsing);
+    if (TerminateParsing)
+      return Errors;
   }
 
   if (OS) {
     // The presence of OS signals verbose dumping.
     DIDumpOptions DumpOptions;
     DumpOptions.Verbose = true;
     Prologue.dump(*OS, DumpOptions);
   }
if (Opcode == 0) {
         // 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) {
-        fprintf(stderr, "Unexpected line op length at offset 0x%8.8" PRIx32
-                " expected 0x%2.2" PRIx64 " found 0x%2.2" PRIx32 "\n",
-                ExtOffset, Len, *OffsetPtr - ExtOffset);
-        // Skip the rest of the line-number program.
-        *OffsetPtr = EndOffset;
-        return false;
+        Errors = joinErrors(
+            std::move(Errors),
+            createError(DebugLineError::Major,
+                        "Unexpected line op length at offset 0x%8.8" PRIx32
+                        " expected 0x%2.2" PRIx64 " found 0x%2.2" PRIx32,
+                        ExtOffset, Len, *OffsetPtr - ExtOffset));
+        return Errors;
       }
     } 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
if (Opcode == 0) {
       // Reset discriminator to 0.
       State.Row.Discriminator = 0;
     }
     if(OS)
       *OS << "\n";
   }
 
   if (!State.Sequence.Empty) {
-    fprintf(stderr, "warning: last sequence in debug line table is not"
-                    "terminated!\n");
+    Errors = joinErrors(std::move(Errors),
+                        createError(DebugLineError::Minor,
+                                    "last sequence in debug line table is not"
+                                    " terminated!"));
   }
 
   // Sort all sequences so that address lookup will work faster.
   if (!Sequences.empty()) {
     std::sort(Sequences.begin(), Sequences.end(), Sequence::orderByLowPC);
     // 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
     // rudimentary sequences for address ranges [0x0, 0xsomething).
   }
 
-  return EndOffset;
+  return Errors;
 }
 
 uint32_t
 DWARFDebugLine::LineTable::findRowInSeq(const DWARFDebugLine::Sequence &Seq,
                                         uint64_t Address) const {
   if (!Seq.containsPC(Address))
     return UnknownRowIndex;
   // Search for instruction address in the rows describing the sequence.

test/DebugInfo/X86/dwarfdump-bogus-LNE.s

LT2_header_end:
         # Real opcode with incorrect length.
         .byte   0
         .byte   2               # Wrong length, should be 1.
         .byte   1               # DW_LNE_end_sequence
 LT2_end:
 
 # ERR:      Unexpected line op length at offset 0x0000005e
 # ERR-SAME: expected 0x02 found 0x01
-
-# The above parsing errors still let us move to the next unit.
-# If the prologue is bogus, we need to bail out because we can't
-# even find the next unit.
-
-# DWARF v4 line-table header #3.
-LT3_start:
-        .long   LT3_end-LT3_version   # Length of Unit (DWARF-32 format)
-LT3_version:
-        .short  4               # DWARF version number
-        .long   LT3_header_end-LT3_params   # Length of Prologue
-LT3_params:
-        .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               # Standard Opcode Lengths
-        .byte   1
-        .byte   1
-        .byte   1
-        .byte   1
-        .byte   0
-        .byte   0
-        .byte   0
-        .byte   1
-        .byte   0
-        .byte   0
-        .byte   1
-        # No directories.
-        .byte   0
-        # No files.
-        .byte   0
-        # Extra junk at the end of the prologue, so the length isn't right.
-        .long   0
-LT3_header_end:
-        # Real opcode and operand.
-        .byte   0
-        .byte   9
-        .byte   2               # DW_LNE_set_address
-        .quad   .text
-        # Real opcode with incorrect length.
-        .byte   0
-        .byte   2               # Wrong length, should be 1.
-        .byte   1               # DW_LNE_end_sequence
-LT3_end:
-
-# We should have bailed out above, so never see this in the dump.
-# DWARF v4 line-table header #4.
-LT4_start:
-        .long   LT4_end-LT4_version   # Length of Unit (DWARF-32 format)
-LT4_version:
-        .short  4               # DWARF version number
-        .long   LT4_header_end-LT4_params   # Length of Prologue
-LT4_params:
-        .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               # Standard Opcode Lengths
-        .byte   1
-        .byte   1
-        .byte   1
-        .byte   1
-        .byte   0
-        .byte   0
-        .byte   0
-        .byte   1
-        .byte   0
-        .byte   0
-        .byte   1
-        # No directories.
-        .byte   0
-        # No files.
-        .byte   0
-LT4_header_end:
-        # Real opcode and operand.
-        .byte   0
-        .byte   9
-        .byte   2               # DW_LNE_set_address
-        .quad   .text
-        # Real opcode with correct length.
-        .byte   0
-        .byte   1
-        .byte   1               # DW_LNE_end_sequence
-LT4_end:
-
-# Look for the dump of unit 3, and don't want unit 4.
-# CHECK:     Line table prologue:
-# CHECK-NOT: Line table prologue:
-
-# And look for the error message.
-# ERR:      warning: parsing line table prologue at 0x0000005f should have
-# ERR-SAME: ended at 0x00000081 but it ended at 0x0000007d

test/DebugInfo/X86/dwarfdump-line-dwo.s

LH_2_params:
         .byte   1               # Directory index
         .byte   0x14            # Timestamp
         .byte   0x24            # File Size
         .byte   0               # End of list
 LH_2_header_end:
         # Line number program, which is empty.
 LH_2_end:
 
+# FIXME: Printing too much stuff
 # PART2:      Line table prologue:
 # PART2-NEXT: total_length: 0x00000028
 # PART2-NEXT: version: 4
 # PART2-NEXT: prologue_length: 0x00000022
 # PART2-NOT:  prologue:
 # PART2:      include_directories[  1] = "Dir2"
 # PART2:      file_names[  1]
 # PART2:      name: "File2"
 # PART2-NOT:  prologue:

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

+.section .debug_line,"",@progbits
+# Leading good section
+.long   .Lunit1_end - .Lunit1_start # Length of Unit (DWARF-32 format)
+.Lunit1_start:
+.short  4               # DWARF version number
+.long   .Lprologue1_end-.Lprologue1_start # Length of Prologue
+.Lprologue1_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
+.Lprologue1_end:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0x0badbeef
+.byte   0, 1, 1         # DW_LNE_end_sequence
+.Lunit1_end:
+
+# version 0
+.long   .Lunit_v0_end - .Lunit_v0_start # unit length
+.Lunit_v0_start:
+.short  0               # version
+.Lunit_v0_end:
+
+# version 1
+.long   .Lunit_v1_end - .Lunit_v1_start # unit length
+.Lunit_v1_start:
+.short  1               # version
+.Lunit_v1_end:
+
+# version 5 malformed line/include table
+.long   .Lunit_v5_end - .Lunit_v5_start # unit length
+.Lunit_v5_start:
+.short  5               # version
+.byte   8               # address size
+.byte   8               # segment selector
+.long   .Lprologue_v5_end-.Lprologue_v5_start # Length of Prologue
+.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)
+.Lprologue_v5_end:
+.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
+.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
+.Lprologue_short_prologue_end:
+.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
+.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   0
+.Lprologue_long_prologue_end:
+.Lunit_long_prologue_end:
+
+# Over-long extended opcode
+.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, 9, 2        # DW_LNE_set_address
+.quad   0xbabb1e45
+.byte   0, 1, 1         # DW_LNE_end_sequence (wrong length)
+.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               # 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_no_eos_end:
+.byte   0, 9, 2        # DW_LNE_set_address
+.quad   0xdeadfade
+.byte   1              # DW_LNS_copy
+.Lunit_no_eos_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
+.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_good_end:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0xcafebabe
+.byte   0, 1, 1         # DW_LNE_end_sequence
+.Lunit_good_end:

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

+.section .debug_line,"",@progbits
+# Leading good section
+.long   .Lunit1_end - .Lunit1_start # Length of Unit (DWARF-32 format)
+.Lunit1_start:
+.short  4               # DWARF version number
+.long   .Lprologue1_end-.Lprologue1_start # Length of Prologue
+.Lprologue1_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
+.Lprologue1_end:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0x0badbeef
+.byte   0, 1, 1         # DW_LNE_end_sequence
+.Lunit1_end:
+
+# Malformed section
+.long   0xfffffffe      # reserved unit length
+
+# Trailing good section
+.long   .Lunit3_end - .Lunit3_start # Length of Unit (DWARF-32 format)
+.Lunit3_start:
+.short  4               # DWARF version number
+.long   .Lprologue3_end-.Lprologue3_start # Length of Prologue
+.Lprologue3_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
+.Lprologue3_end:
+.byte   0, 9, 2         # DW_LNE_set_address
+.quad   0xcafebabe
+.byte   0, 1, 1         # DW_LNE_end_sequence
+.Lunit3_end:

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.
+
+# 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: 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: 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: 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: 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,TERSE
+# 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,VERBOSE
+# 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: 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=0x183 %t-malformed.o 2> %t-malformed-off-last.err | FileCheck %s --check-prefixes=LASTONLY
+# 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 malformed table should not be dumped, nor should the following table.
+# FATAL: debug_line[0x00000048]
+# FATAL-NOT: Line table prologue
+# FATAL-NOT: debug_line
+
+# For non-fatal issues, the malformed table should not be dumped, but any subsequent ones should be.
+# NONFATAL: debug_line[0x00000048]
+# NONFATAL-NOT: Line table prologue
+# NONFATAL: debug_line[0x0000004e]
+# NONFATAL-NOT: Line table prologue
+# NONFATAL: debug_line[0x00000054]
+# NONFATAL-NOT: Line table prologue
+# NONFATAL: debug_line[0x00000073]
+# NONFATAL-NOT: Line table prologue
+# NONFATAL: debug_line[0x000000ad]
+# NONFATAL-NOT: Line table prologue
+# NONFATAL: debug_line[0x000000e7]
+# TERSE-NOT: Line table prologue
+# Verbose dumping prints the line table prologue and any valid operations up to the point causing
+# the problem.
+# VERBOSE-NEXT: Line table prologue
+# VERBOSE: 0x00000000abbadaba {{.*}} end_sequence
+# VERBOSE-NOT: DW_LNE_set_address
+
+# For minor issues, we can dump the table.
+# NONFATAL: debug_line[0x0000013d]
+# NONFATAL-NEXT: Line table prologue
+# NONFATAL-NOT: debug_line[{{.*}}]
+# NONFATAL: 0x00000000deadfade {{.*}}
+# NONFATAL: debug_line[0x00000183]
+# NONFATAL-NOT: debug_line[{{.*}}]
+# NONFATAL: 0x00000000cafebabe {{.*}} end_sequence
+# NONFATAL-NOT: debug_line[{{.*}}]
+
+# LASTONLY-NOT: debug_line[{{.*}}]
+# LASTONLY: debug_line[0x00000183]
+# LASTONLY: 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
+# 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
+# OTHER-NEXT: warning: last sequence in debug line table is not terminated!
+# ALL-NOT:  warning:

tools/dsymutil/DwarfLinker.cpp

if (auto *OutputDIE = Unit.getOutputUnitDIE())
     patchStmtList(*OutputDIE, DIEInteger(Streamer->getLineSectionSize()));
 
   // Parse the original line info for the unit.
   DWARFDebugLine::LineTable LineTable;
   uint32_t StmtOffset = *StmtList;
   DWARFDataExtractor LineExtractor(
       OrigDwarf.getDWARFObj(), OrigDwarf.getDWARFObj().getLineSection(),
       OrigDwarf.isLittleEndian(), Unit.getOrigUnit().getAddressByteSize());
-  LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf, &Unit.getOrigUnit());
+
+  Error Err = LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf,
+                              &Unit.getOrigUnit());
+  handleDebugLineParseErrors(std::move(Err));
 
   // This vector is the output line table.
   std::vector<DWARFDebugLine::Row> NewRows;
   NewRows.reserve(LineTable.Rows.size());
 
   // Current sequence of rows being extracted, before being inserted
   // in NewRows.
   std::vector<DWARFDebugLine::Row> Seq;

unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace dwarf;
+using namespace dwarfgen;
 using namespace object;
 using namespace utils;
+using namespace testing;
 
 namespace {
 
-struct DebugLineGenerator {
-  bool init() {
+struct CommonFixture {
+  CommonFixture() : LineData("", true, 0){};
+
+  bool setupGenerator(uint16_t Version = 4) {
     Triple T = getHostTripleForAddrSize(8);
     if (!isConfigurationSupported(T))
       return false;
-    auto ExpectedGenerator = dwarfgen::Generator::create(T, 4);
+    auto ExpectedGenerator = Generator::create(T, Version);
     if (ExpectedGenerator)
       Generator.reset(ExpectedGenerator->release());
     return true;
   }
 
+  void generate() {
+    Context = createContext();
+    assert(Context != nullptr && "test state is not valid");
+    const DWARFObject &Obj = Context->getDWARFObj();
+    LineData = DWARFDataExtractor(Obj, Obj.getLineSection(), true, 8);
+  }
+
   std::unique_ptr<DWARFContext> createContext() {
     if (!Generator)
       return nullptr;
     StringRef FileBytes = Generator->generate();
     MemoryBufferRef FileBuffer(FileBytes, "dwarf");
     auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
     if (Obj)
       return DWARFContext::create(**Obj);
     return nullptr;
   }
 
-  std::unique_ptr<dwarfgen::Generator> Generator;
+  std::unique_ptr<Generator> Generator;
+  std::unique_ptr<DWARFContext> Context;
+  DWARFDataExtractor LineData;
+  DWARFDebugLine Line;
+};
+
+// Fixtures must derive from "Test", but parameterised fixtures from
+// "TestWithParam". It does not seem possible to inherit from both, so we share
+// the common state in a separate class, inherited by the two fixture classes.
+struct DebugLineBasicFixture : public Test, public CommonFixture {};
+
+struct DebugLineParameterisedFixture
+    : public TestWithParam<std::pair<uint16_t, DwarfFormat>>,
+      public CommonFixture {
+  void SetUp() { std::tie(Version, Format) = GetParam(); }
+
+  uint16_t Version;
+  DwarfFormat Format;
 };
 
-TEST(DWARFDebugLine, GetLineTableAtInvalidOffset) {
-  DebugLineGenerator LineGen;
-  if (!LineGen.init())
+void checkLineParserError(Error Err, std::vector<DebugLineError> Expected) {
+  if (Expected.empty())
+    ASSERT_FALSE(Err);
+  size_t Index = 0;
+  handleAllErrors(std::move(Err), [&](const DebugLineError &Actual) {
+    SCOPED_TRACE("Checking error #" + std::to_string(Index));
+    ASSERT_LT(Index, Expected.size());
+    const DebugLineError &Expect = Expected[Index++];
+    EXPECT_EQ(Actual.getSeverity(), Expect.getSeverity());
+    EXPECT_EQ(Actual.message(), Expect.message());
+  });
+  EXPECT_EQ(Index, Expected.size());
+}
+
+TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffset) {
+  if (!setupGenerator())
     return;
+  generate();
 
-  DWARFDebugLine Line;
-  std::unique_ptr<DWARFContext> Context = LineGen.createContext();
-  ASSERT_TRUE(Context != nullptr);
-  const DWARFObject &Obj = Context->getDWARFObj();
-  DWARFDataExtractor LineData(Obj, Obj.getLineSection(), true, 8);
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(
+          DebugLineError::Fatal,
+          "offset 0x00000000 is not a valid debug line section offset")});
+
+  // Repeat to show that an error is reported each time.
+  LineTableAndErr = Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(
+          DebugLineError::Fatal,
+          "offset 0x00000000 is not a valid debug line section offset")});
+
+  // Show that an error is reported for later offsets too.
+  LineTableAndErr = Line.getOrParseLineTable(LineData, 1, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(
+          DebugLineError::Fatal,
+          "offset 0x00000001 is not a valid debug line section offset")});
+}
+
+TEST_P(DebugLineParameterisedFixture, GetOrParseLineTableValidTable) {
+  if (!setupGenerator(Version))
+    return;
+
+  SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
+               (Format == DWARF64 ? "DWARF64" : "DWARF32"));
+
+  LineTable &LT = Generator->addLineTable(Format);
+  LT.addExtendedOpcode(9, DW_LNE_set_address, {{0xadd4e55, LineTable::Quad}});
+  LT.addStandardOpcode(DW_LNS_copy, {});
+  LT.addByte(0xaa);
+  LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+
+  LineTable &LT2 = Generator->addLineTable();
+  LT2.addExtendedOpcode(9, DW_LNE_set_address, {{0x11223344, LineTable::Quad}});
+  LT2.addStandardOpcode(DW_LNS_copy, {});
+  LT2.addByte(0xbb);
+  LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+  LT2.addExtendedOpcode(9, DW_LNE_set_address, {{0x55667788, LineTable::Quad}});
+  LT2.addStandardOpcode(DW_LNS_copy, {});
+  LT2.addByte(0xcc);
+  LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+
+  generate();
+
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  checkLineParserError(std::move(LineTableAndErr.Err), {});
+  ASSERT_NE(LineTableAndErr.Table, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table->Sequences.size(), 1);
+
+  uint64_t SecondOffset = LineTableAndErr.Table->Prologue.sizeofTotalLength() +
+                          LineTableAndErr.Table->Prologue.TotalLength;
+  auto LineTableAndErr2 =
+      Line.getOrParseLineTable(LineData, SecondOffset, *Context, nullptr);
+  checkLineParserError(std::move(LineTableAndErr2.Err), {});
+  ASSERT_NE(LineTableAndErr2.Table, nullptr);
+  EXPECT_EQ(LineTableAndErr2.Table->Sequences.size(), 2);
+
+  // Check that if the same offset is requested, the exact same pointer is
+  // returned.
+  auto LineTableAndErr3 =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  checkLineParserError(std::move(LineTableAndErr.Err), {});
+  EXPECT_EQ(LineTableAndErr.Table, LineTableAndErr3.Table);
+
+  auto LineTableAndErr4 =
+      Line.getOrParseLineTable(LineData, SecondOffset, *Context, nullptr);
+  checkLineParserError(std::move(LineTableAndErr.Err), {});
+  EXPECT_EQ(LineTableAndErr2.Table, LineTableAndErr4.Table);
+}
+
+TEST_F(DebugLineBasicFixture, FatalErrorForReservedLength) {
+  if (!setupGenerator())
+    return;
+
+  LineTable &LT = Generator->addLineTable();
+  LT.setCustomPrologue({{0xffffff00, LineTable::Long}});
+
+  generate();
+
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(DebugLineError::Fatal,
+                      "parsing line table prologue at offset "
+                      "0x00000000 unsupported reserved unit length "
+                      "found of value 0xffffff00")});
+}
+
+TEST_F(DebugLineBasicFixture, MajorErrorForLowVersion) {
+  if (!setupGenerator())
+    return;
+
+  LineTable &LT = Generator->addLineTable();
+  LT.setCustomPrologue(
+      {{LineTable::Half, LineTable::Long}, {1, LineTable::Half}});
+
+  generate();
+
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(DebugLineError::Major,
+                      "parsing line table prologue at offset "
+                      "0x00000000 found unsupported version 0x01")});
+}
+
+TEST_F(DebugLineBasicFixture, MajorErrorForInvalidV5IncludeDirTable) {
+  if (!setupGenerator(5))
+    return;
+
+  LineTable &LT = Generator->addLineTable();
+  LT.setCustomPrologue({
+      {19, LineTable::Long}, // unit length
+      {5, LineTable::Half},  // version
+      {8, LineTable::Byte},  // addr size
+      {0, LineTable::Byte},  // segment selector size
+      {11, LineTable::Long}, // prologue length
+      {1, LineTable::Byte},  // min instruction length
+      {1, LineTable::Byte},  // max ops per instruction
+      {1, LineTable::Byte},  // default is_stmt
+      {0, LineTable::Byte},  // line base
+      {14, LineTable::Byte}, // line range
+      {2, LineTable::Byte},  // opcode base (small to reduce the amount of
+                             // setup required).
+      {0, LineTable::Byte},  // standard opcode lengths
+      {0, LineTable::Byte},  // directory entry format count (should not be
+                             // zero).
+      {0, LineTable::ULEB},  // directories count
+      {0, LineTable::Byte},  // file name entry format count
+      {0, LineTable::ULEB}   // file name entry count
+  });
+
+  generate();
+
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(DebugLineError::Major,
+                      "parsing line table prologue at 0x00000000"
+                      " found an invalid directory or file table description "
+                      "at 0x00000014")});
+}
+
+TEST_P(DebugLineParameterisedFixture, MajorErrorForTooLargePrologueLength) {
+  if (!setupGenerator(Version))
+    return;
+
+  SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
+               (Format == DWARF64 ? "DWARF64" : "DWARF32"));
+
+  LineTable &LT = Generator->addLineTable(Format);
+  DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
+  ++Prologue.PrologueLength;
+  LT.setPrologue(Prologue);
+
+  generate();
+
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+
+  uint64_t ExpectedEnd =
+      Prologue.TotalLength + 1 + Prologue.sizeofTotalLength();
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(DebugLineError::Major,
+                      Twine("parsing line table prologue at 0x00000000 should "
+                            "have ended at 0x000000") +
+                          Twine::utohexstr(ExpectedEnd) +
+                          " but it ended at 0x000000" +
+                          Twine::utohexstr(ExpectedEnd - 1))});
+}
+
+TEST_P(DebugLineParameterisedFixture, MajorErrorForTooShortPrologueLength) {
+  if (!setupGenerator(Version))
+    return;
+
+  SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
+               (Format == DWARF64 ? "DWARF64" : "DWARF32"));
+
+  LineTable &LT = Generator->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 LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+
+  uint64_t ExpectedEnd =
+      Prologue.TotalLength - 1 + Prologue.sizeofTotalLength();
+  if (Version < 5)
+    --ExpectedEnd;
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(DebugLineError::Major,
+                      Twine("parsing line table prologue at 0x00000000 should "
+                            "have ended at 0x000000") +
+                          Twine::utohexstr(ExpectedEnd) +
+                          " but it ended at 0x000000" +
+                          Twine::utohexstr(ExpectedEnd + 1))});
+}
+
+// FIXME: Use ::testing::Combine() when llvm updates its copy of googletest.
+INSTANTIATE_TEST_CASE_P(
+    LineTableTestParams, DebugLineParameterisedFixture,
+    Values(std::make_pair(2, DWARF32), std::make_pair(3, DWARF32),
+           std::make_pair(4, DWARF32), std::make_pair(5, DWARF32),
+           std::make_pair(2, DWARF64), std::make_pair(3, DWARF64),
+           std::make_pair(4, DWARF64), std::make_pair(5, DWARF64)));
+
+TEST_F(DebugLineBasicFixture, MajorErrorForInvalidExtendedOpcodeLength) {
+  if (!setupGenerator())
+    return;
+
+  LineTable &LT = Generator->addLineTable();
+  // The Length should be 1 for an end sequence opcode.
+  LT.addExtendedOpcode(2, DW_LNE_end_sequence, {});
+
+  generate();
+
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table, nullptr);
+  checkLineParserError(std::move(LineTableAndErr.Err),
+                       {DebugLineError(DebugLineError::Major,
+                                       "Unexpected line op length at offset "
+                                       "0x00000030 expected 0x02 found 0x01")});
+}
+
+TEST_F(DebugLineBasicFixture, MinorErrorForUnterminatedSequence) {
+  if (!setupGenerator())
+    return;
+
+  LineTable &LT = Generator->addLineTable();
+  // The Length should be 1 for an end sequence opcode.
+  LT.addExtendedOpcode(9, DW_LNE_set_address,
+                       {{0x1122334455667788, LineTable::Quad}});
+  LT.addStandardOpcode(DW_LNS_copy, {});
+  LT.addByte(0xaa);
+  LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+  LT.addExtendedOpcode(9, DW_LNE_set_address,
+                       {{0x99aabbccddeeff00, LineTable::Quad}});
+  LT.addStandardOpcode(DW_LNS_copy, {});
+  LT.addByte(0xbb);
+  LT.addByte(0xcc);
+
+  generate();
 
-  EXPECT_EQ(Line.getOrParseLineTable(LineData, 0, *Context, nullptr), nullptr);
+  auto LineTableAndErr =
+      Line.getOrParseLineTable(LineData, 0, *Context, nullptr);
+  checkLineParserError(
+      std::move(LineTableAndErr.Err),
+      {DebugLineError(DebugLineError::Minor,
+                      "last sequence in debug line table is not terminated!")});
+  ASSERT_NE(LineTableAndErr.Table, nullptr);
+  EXPECT_EQ(LineTableAndErr.Table->Rows.size(), 6);
+  // The unterminated sequence is not added to the sequence list.
+  EXPECT_EQ(LineTableAndErr.Table->Sequences.size(), 1);
 }
 
 } // end anonymous namespace

unittests/DebugInfo/DWARF/DwarfGenerator.h

public:
   uint64_t getOffset() const { return DU.getDebugSectionOffset(); }
   uint64_t getLength() const { return DU.getLength(); }
   uint16_t getVersion() const { return DU.getDwarfVersion(); }
   uint16_t getAddressSize() const { return DU.getAddressSize(); }
   void setOffset(uint64_t Offset) { DU.setDebugSectionOffset(Offset); }
   void setLength(uint64_t Length) { DU.setLength(Length); }
 };
 
+/// A DWARF line unit-like class used to generate DWARF line units.
+///
+/// Instances of this class are created by instances of the Generator class.
+class LineTable {
+public:
+  enum ValueLength { Byte = 1, Half = 2, Long = 4, Quad = 8, ULEB, SLEB };
+
+  struct ValueAndLength {
+    uint64_t Value;
+    ValueLength Length;
+  };
+
+  LineTable(Generator &DG, uint16_t Version, dwarf::DwarfFormat Dwarf64,
+            uint8_t AddrSize, uint8_t SegSize = 0)
+      : DG(DG), Version(Version), Format(Dwarf64), AddrSize(AddrSize),
+        SegSize(SegSize) {
+    assert(Version >= 2 && Version <= 5 && "unsupported version");
+  }
+
+  // Create a Prologue suitable to pass to setPrologue, with a single file and
+  // include directory entry.
+  DWARFDebugLine::Prologue createBasicPrologue() const;
+
+  // Set or replace the current prologue with the specified prologue. If no
+  // prologue is set, a default one will be used when generating.
+  void setPrologue(DWARFDebugLine::Prologue NewPrologue);
+  // Used to write an arbitrary payload instead of the standard prologue. This
+  // is useful if you wish to test handling of corrupt .debug_line sections.
+  void setCustomPrologue(ArrayRef<ValueAndLength> NewPrologue);
+
+  // Add a byte to the program, with the given value. This can be used to
+  // specify a special opcode, or to add arbitrary contents to the section.
+  void addByte(uint8_t Value);
+  // Add a standard opcode to the program. The opcode and operands do not have
+  // to be valid.
+  void addStandardOpcode(uint8_t Opcode, ArrayRef<ValueAndLength> Operands);
+  // Add an extended opcode to the program with the specified length, opcode,
+  // and operands. These values do not have to be valid.
+  void addExtendedOpcode(uint64_t Length, uint8_t Opcode,
+                         ArrayRef<ValueAndLength> Operands);
+
+  // Write the contents of the LineUnit to the current section in the generator.
+  void generate(MCContext &MC, AsmPrinter &Asm) const;
+
+private:
+  void writeData(ArrayRef<ValueAndLength> Data, AsmPrinter &Asm) const;
+  MCSymbol *writeDefaultPrologue(AsmPrinter &Asm) const;
+  void writePrologue(AsmPrinter &Asm) const;
+
+  void writeProloguePayload(const DWARFDebugLine::Prologue &Prologue,
+                            AsmPrinter &Asm) const;
+
+  Generator &DG;
+  llvm::Optional<DWARFDebugLine::Prologue> Prologue;
+  std::vector<ValueAndLength> CustomPrologue;
+  std::vector<ValueAndLength> Contents;
+
+  // The Version field is used for determining how to write the Prologue, if a
+  // non-custom prologue is used. The version value actually written, will be
+  // that specified in the Prologue, if a custom prologue has been passed in.
+  // Otherwise, it will be this value.
+  uint16_t Version;
+
+  uint8_t AddrSize;
+  uint8_t SegSize;
+  dwarf::DwarfFormat Format;
+};
+
 /// A DWARF generator.
 ///
 /// Generate DWARF for unit tests by creating any instance of this class and
 /// calling Generator::addCompileUnit(), and then getting the dwarfgen::DIE from
 /// the returned compile unit and adding attributes and children to each DIE.
 class Generator {
   std::unique_ptr<MCRegisterInfo> MRI;
   std::unique_ptr<MCAsmInfo> MAI;
   std::unique_ptr<MCObjectFileInfo> MOFI;
   std::unique_ptr<MCContext> MC;
   MCAsmBackend *MAB; // Owned by MCStreamer
   std::unique_ptr<MCInstrInfo> MII;
   std::unique_ptr<MCSubtargetInfo> MSTI;
   MCCodeEmitter *MCE; // Owned by MCStreamer
   MCStreamer *MS;     // Owned by AsmPrinter
   std::unique_ptr<TargetMachine> TM;
   std::unique_ptr<AsmPrinter> Asm;
   BumpPtrAllocator Allocator;
   std::unique_ptr<DwarfStringPool> StringPool; // Entries owned by Allocator.
   std::vector<std::unique_ptr<CompileUnit>> CompileUnits;
+  std::vector<std::unique_ptr<LineTable>> LineTables;
   DIEAbbrevSet Abbreviations;
 
   SmallString<4096> FileBytes;
   /// The stream we use to generate the DWARF into as an ELF file.
   std::unique_ptr<raw_svector_ostream> Stream;
   /// The DWARF version to generate.
   uint16_t Version;
 
public:
   /// Generate all DWARF sections and return a memory buffer that
   /// contains an ELF file that contains the DWARF.
   StringRef generate();
 
   /// Add a compile unit to be generated.
   ///
   /// \returns a dwarfgen::CompileUnit that can be used to retrieve the compile
   /// unit dwarfgen::DIE that can be used to add attributes and add child DIE
-  /// objedts to.
+  /// objects to.
   dwarfgen::CompileUnit &addCompileUnit();
 
+  /// Add a line table unit to be generated.
+  /// \param Dwarf64 whether to use 32-bit or 64-bit DWARF.
+  ///
+  /// \returns a dwarfgen::LineTable that can be used to customise the contents
+  /// of the line table.
+  LineTable &
+  addLineTable(dwarf::DwarfFormat Dwarf64 = dwarf::DwarfFormat::DWARF32);
+
   BumpPtrAllocator &getAllocator() { return Allocator; }
   AsmPrinter *getAsmPrinter() const { return Asm.get(); }
   MCContext *getMCContext() const { return MC.get(); }
   DIEAbbrevSet &getAbbrevSet() { return Abbreviations; }
   DwarfStringPool &getStringPool() { return *StringPool; }
 
   /// Save the generated DWARF file to disk.
   ///

unittests/DebugInfo/DWARF/DwarfGenerator.cpp

return dwarfgen::DIE(CU,
                        &Die->addChild(llvm::DIE::get(DG.getAllocator(), Tag)));
 }
 
 dwarfgen::DIE dwarfgen::CompileUnit::getUnitDIE() {
   return dwarfgen::DIE(this, &DU.getUnitDie());
 }
 
 //===----------------------------------------------------------------------===//
+/// dwarfgen::LineTable implementation.
+//===----------------------------------------------------------------------===//
+DWARFDebugLine::Prologue dwarfgen::LineTable::createBasicPrologue() const {
+  DWARFDebugLine::Prologue P;
+  switch (Version) {
+  case 2:
+  case 3:
+    P.TotalLength = 41;
+    P.PrologueLength = 35;
+    break;
+  case 4:
+    P.TotalLength = 42;
+    P.PrologueLength = 36;
+    break;
+  case 5:
+    P.TotalLength = 47;
+    P.PrologueLength = 39;
+    P.FormParams.AddrSize = AddrSize;
+    break;
+  default:
+    llvm_unreachable("unsupported version");
+  }
+  if (Format == DWARF64) {
+    P.TotalLength += 4;
+    P.FormParams.Format = DWARF64;
+  }
+  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};
+  P.IncludeDirectories.push_back(DWARFFormValue(DW_FORM_string));
+  P.IncludeDirectories.back().setPValue("a dir");
+  P.FileNames.push_back(DWARFDebugLine::FileNameEntry());
+  P.FileNames.back().Name.setPValue("a file");
+  P.FileNames.back().Name.setForm(DW_FORM_string);
+  return P;
+}
+
+void dwarfgen::LineTable::setPrologue(DWARFDebugLine::Prologue NewPrologue) {
+  Prologue = NewPrologue;
+  CustomPrologue.clear();
+}
+
+void dwarfgen::LineTable::setCustomPrologue(
+    ArrayRef<ValueAndLength> NewPrologue) {
+  Prologue = None;
+  CustomPrologue = NewPrologue;
+}
+
+void dwarfgen::LineTable::addByte(uint8_t Value) {
+  Contents.push_back({Value, Byte});
+}
+
+void dwarfgen::LineTable::addStandardOpcode(uint8_t Opcode,
+                                            ArrayRef<ValueAndLength> Operands) {
+  Contents.push_back({Opcode, Byte});
+  Contents.insert(Contents.end(), Operands.begin(), Operands.end());
+}
+
+void dwarfgen::LineTable::addExtendedOpcode(uint64_t Length, uint8_t Opcode,
+                                            ArrayRef<ValueAndLength> Operands) {
+  Contents.push_back({0, Byte});
+  Contents.push_back({Length, ULEB});
+  Contents.push_back({Opcode, Byte});
+  Contents.insert(Contents.end(), Operands.begin(), Operands.end());
+}
+
+void dwarfgen::LineTable::generate(MCContext &MC, AsmPrinter &Asm) const {
+  MC.setDwarfVersion(Version);
+
+  MCSymbol *EndSymbol = nullptr;
+  if (!CustomPrologue.empty()) {
+    writeData(CustomPrologue, Asm);
+  } else if (!Prologue) {
+    EndSymbol = writeDefaultPrologue(Asm);
+  } else {
+    writePrologue(Asm);
+  }
+
+  writeData(Contents, Asm);
+  if (EndSymbol != nullptr)
+    Asm.OutStreamer->EmitLabel(EndSymbol);
+}
+
+void dwarfgen::LineTable::writeData(ArrayRef<ValueAndLength> Data,
+                                    AsmPrinter &Asm) const {
+  for (auto Entry : Data) {
+    switch (Entry.Length) {
+    case Byte:
+    case Half:
+    case Long:
+    case Quad:
+      Asm.OutStreamer->EmitIntValue(Entry.Value, Entry.Length);
+      break;
+    case ULEB:
+      Asm.EmitULEB128(Entry.Value);
+      break;
+    case SLEB:
+      Asm.EmitSLEB128(Entry.Value);
+      break;
+    default:
+      llvm_unreachable("unsupported ValueAndLength Length value");
+    }
+  }
+}
+
+MCSymbol *dwarfgen::LineTable::writeDefaultPrologue(AsmPrinter &Asm) const {
+  MCSymbol *UnitStart = Asm.createTempSymbol("line_unit_start");
+  MCSymbol *UnitEnd = Asm.createTempSymbol("line_unit_end");
+  if (Format == DwarfFormat::DWARF64) {
+    Asm.EmitInt32(0xffffffff);
+    Asm.EmitLabelDifference(UnitEnd, UnitStart, 8);
+  } else {
+    Asm.EmitLabelDifference(UnitEnd, UnitStart, 4);
+  }
+  Asm.OutStreamer->EmitLabel(UnitStart);
+  Asm.EmitInt16(Version);
+  if (Version == 5) {
+    Asm.EmitInt8(AddrSize);
+    Asm.EmitInt8(SegSize);
+  }
+
+  MCSymbol *PrologueStart = Asm.createTempSymbol("line_prologue_start");
+  MCSymbol *PrologueEnd = Asm.createTempSymbol("line_prologue_end");
+  Asm.EmitLabelDifference(PrologueEnd, PrologueStart,
+                          Format == DwarfFormat::DWARF64 ? 8 : 4);
+  Asm.OutStreamer->EmitLabel(PrologueStart);
+
+  DWARFDebugLine::Prologue DefaultPrologue = createBasicPrologue();
+  writeProloguePayload(DefaultPrologue, Asm);
+  Asm.OutStreamer->EmitLabel(PrologueEnd);
+  return UnitEnd;
+}
+
+void dwarfgen::LineTable::writePrologue(AsmPrinter &Asm) const {
+  if (Format == DwarfFormat::DWARF64) {
+    Asm.EmitInt32(0xffffffff);
+    Asm.EmitInt64(Prologue->TotalLength);
+  } else {
+    Asm.EmitInt32(Prologue->TotalLength);
+  }
+  Asm.EmitInt16(Prologue->getVersion());
+  if (Version == 5) {
+    Asm.EmitInt8(Prologue->getAddressSize());
+    Asm.EmitInt8(Prologue->SegSelectorSize);
+  }
+  if (Format == DwarfFormat::DWARF64)
+    Asm.EmitInt64(Prologue->PrologueLength);
+  else
+    Asm.EmitInt32(Prologue->PrologueLength);
+
+  writeProloguePayload(*Prologue, Asm);
+}
+
+static void writeCString(StringRef Str, AsmPrinter &Asm) {
+  Asm.OutStreamer->EmitBytes(Str);
+  Asm.EmitInt8(0);
+}
+
+static void writeV2IncludeAndFileTable(const DWARFDebugLine::Prologue &Prologue,
+                                       AsmPrinter &Asm) {
+  for (auto Include : Prologue.IncludeDirectories) {
+    assert(Include.getAsCString() && "expected a string form for include dir");
+    writeCString(*Include.getAsCString(), Asm);
+  }
+  Asm.EmitInt8(0);
+
+  for (auto File : Prologue.FileNames) {
+    assert(File.Name.getAsCString() && "expected a string form for file name");
+    writeCString(*File.Name.getAsCString(), Asm);
+    Asm.EmitULEB128(File.DirIdx);
+    Asm.EmitULEB128(File.ModTime);
+    Asm.EmitULEB128(File.Length);
+  }
+  Asm.EmitInt8(0);
+}
+
+static void writeV5IncludeAndFileTable(const DWARFDebugLine::Prologue &Prologue,
+                                       AsmPrinter &Asm) {
+  Asm.EmitInt8(1); // directory_entry_format_count.
+  // TODO: Add support for other content descriptions - we currently only
+  // support a single DW_LNCT_path/DW_FORM_string.
+  Asm.EmitULEB128(DW_LNCT_path);
+  Asm.EmitULEB128(DW_FORM_string);
+  Asm.EmitULEB128(Prologue.IncludeDirectories.size());
+  for (auto Include : Prologue.IncludeDirectories) {
+    assert(Include.getAsCString() && "expected a string form for include dir");
+    writeCString(*Include.getAsCString(), Asm);
+  }
+
+  Asm.EmitInt8(1); // file_name_entry_format_count.
+  Asm.EmitULEB128(DW_LNCT_path);
+  Asm.EmitULEB128(DW_FORM_string);
+  Asm.EmitULEB128(Prologue.FileNames.size());
+  for (auto File : Prologue.FileNames) {
+    assert(File.Name.getAsCString() && "expected a string form for file name");
+    writeCString(*File.Name.getAsCString(), Asm);
+  }
+}
+
+void dwarfgen::LineTable::writeProloguePayload(
+    const DWARFDebugLine::Prologue &Prologue, AsmPrinter &Asm) const {
+  Asm.EmitInt8(Prologue.MinInstLength);
+  if (Version >= 4)
+    Asm.EmitInt8(Prologue.MaxOpsPerInst);
+  Asm.EmitInt8(Prologue.DefaultIsStmt);
+  Asm.EmitInt8(Prologue.LineBase);
+  Asm.EmitInt8(Prologue.LineRange);
+  Asm.EmitInt8(Prologue.OpcodeBase);
+  for (auto Length : Prologue.StandardOpcodeLengths) {
+    Asm.EmitInt8(Length);
+  }
+
+  if (Version < 5)
+    writeV2IncludeAndFileTable(Prologue, Asm);
+  else
+    writeV5IncludeAndFileTable(Prologue, Asm);
+}
+
+//===----------------------------------------------------------------------===//
 /// dwarfgen::Generator implementation.
 //===----------------------------------------------------------------------===//
 
 dwarfgen::Generator::Generator()
     : MAB(nullptr), MCE(nullptr), MS(nullptr), StringPool(nullptr),
       Abbreviations(Allocator) {}
 dwarfgen::Generator::~Generator() = default;
 
for (auto &CU : CompileUnits) {
     } else {
       Asm->EmitInt8(dwarf::DW_UT_compile);
       Asm->EmitInt8(CU->getAddressSize());
       Asm->EmitInt32(0);
     }
     Asm->emitDwarfDIE(*CU->getUnitDIE().Die);
   }
 
+  MS->SwitchSection(MOFI->getDwarfLineSection());
+  for (auto &LT : LineTables) {
+    LT->generate(*MC, *Asm);
+  }
+
   MS->Finish();
   if (FileBytes.empty())
     return StringRef();
   return StringRef(FileBytes.data(), FileBytes.size());
 }
 
 bool dwarfgen::Generator::saveFile(StringRef Path) {
   if (FileBytes.empty())
     return false;
   std::error_code EC;
   raw_fd_ostream Strm(Path, EC, sys::fs::F_None);
   if (EC)
     return false;
   Strm.write(FileBytes.data(), FileBytes.size());
   Strm.close();
   return true;
 }
 
 dwarfgen::CompileUnit &dwarfgen::Generator::addCompileUnit() {
   CompileUnits.push_back(std::unique_ptr<CompileUnit>(
       new CompileUnit(*this, Version, Asm->getPointerSize())));
   return *CompileUnits.back();
 }
+
+dwarfgen::LineTable &dwarfgen::Generator::addLineTable(DwarfFormat Dwarf64) {
+  LineTables.push_back(std::unique_ptr<LineTable>(
+      new LineTable(*this, Version, Dwarf64, Asm->getPointerSize())));
+  return *LineTables.back();
+}