[DebugInfo] Print non-verbose output at same point as verbose output

[jhenderson]

Summary

Verbose and non-verbose parsing of .debug_line produced their output at different points in the program. The most obvious impact of this was that error messages were produced at different times, but it also potentially reduced what clients could do by customising the stream or warning/error handlers.

This change makes the two variants consistent by printing non-verbose output inline, the same as verbose output.

Testing of the error messages has been modified to check the messages always appear in the same location to illustrate the behaviour.

Depends on D80803.
Also depends on D80874.

[dblaikie]

Not a huge fan of this - seems like a bit of a contortion & I'm not sure the consistency of where warnings are printed is all that important? (perhaps this is more of the path that I'd have liked to avoid by not syncing/flushing/trying to line up these things in the first place)

Alternatively, though - could the APIs be changed here to make them more similar/consistent - rather than having an API that prints out and returns a result? What about going the other way and having a callback API that's called back for processed lines and unprocessed lines - and then it's printed on a per-line-table-entry basis, rather than buffered and dumped at the end? Eh, guess then you'd need a separate callback for the header too, etc.

[jhenderson]

In D80989#2069112, @dblaikie wrote:

Not a huge fan of this - seems like a bit of a contortion & I'm not sure the consistency of where warnings are printed is all that important? (perhaps this is more of the path that I'd have liked to avoid by not syncing/flushing/trying to line up these things in the first place)

Alternatively, though - could the APIs be changed here to make them more similar/consistent - rather than having an API that prints out and returns a result? What about going the other way and having a callback API that's called back for processed lines and unprocessed lines - and then it's printed on a per-line-table-entry basis, rather than buffered and dumped at the end? Eh, guess then you'd need a separate callback for the header too, etc.

There's probably an easier way, thinking about it - rather than have the verbose output behaviour be controlled by the presence of OS or not, simply pass in a separate Verbose argument for verbose output, and OS for verbose or non-verbose output. In other words, the three usages would become:

1. No output at all - don't pass in OS and set Verbose to false (or possibly it doesn't matter). Code will just populate the rows, sequences etc.
2. Brief non-verbose output - pass in OS and set Verbose to false. Code will populate the data structures and also print the rows as it goes, like the current verbose output, except without the instruction details etc.
3. Verbose output - pass in OS and set Verbose to true. Code will behave the same as currently.

The second and third options differ in that some output is only printed in verbose mode, whilst other output is printed always. This feels more natural to me as an interface anyway. I'll take a look at that as an alternative. It will give us more consistent timings of when things are printed (possibly important if people are doing some crazy things with custom streams, plus helps with error message timing) without significantly complicating the interface or having to buffer the output unnecessarily.

[jhenderson]

I actually think I prefer my API change suggestion to this patch, so I'm going to look at that now.

[jhenderson]

Completely change approach by changing the parsing API to take both a stream and verbose boolean - the presence of the stream indicates output should be emitted, whilst the boolean indicates whether verbose output should be emitted. This means that verbose and non-verbose output will be emitted at the same time. This patch also rebases the change on top of D80874, but a side-effect is that non-verbose output now includes a header if there are any opcodes whereas before it only included the column headers for a table where there are one or more rows. There is unlikely to be much difference between the two.

[jhenderson]

Could I get another review of this now? I think it solves the problems of the previous version.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

923–924

This is one of several places where new line printing seems incorrect. I am preparing a patch to fix this, and leaving this code in for now to minimise the number of behaviour changes in this patch.

[dblaikie]

Looks good - some optional feedback.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

744–749

Maybe put this outside the while loop so it doesn't have to be tested every time?

if (*OffsetPtr < EndOffset && OS)
  Row::dumpTableHeader(*OS << '\n', Verbose ? 12 : 0);
while (*OffsetPtr < EndOffset)
  ...

Though it does mean duplicating the loop condition (could put it in a lambda), which isn't ideal either - certainly up to you, just figured I'd float the idea.

920–922

Could drop the braces here

[jhenderson]

Rebase on latest version of D80874, and addressed @dblaikie's comments.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

744–749

This was solved by rebasing on @MaskRay's latest version of D80874.

920–922

Done, thanks.

[MaskRay]

Looks great!

[jhenderson]

Rebase and fix a number of small issues. Feel free to give me any post-commit comments.

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

struct LineTable {
 
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     void clear();
 
     /// Parse prologue and all rows.
     Error parse(DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
                 const DWARFContext &Ctx, const DWARFUnit *U,
                 function_ref<void(Error)> RecoverableErrorHandler,
-                raw_ostream *OS = nullptr);
+                raw_ostream *OS = nullptr, bool Verbose = false);
 
     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;
public:
     /// handlers.
     ///
     /// \param RecoverableErrorHandler - any issues that don't prevent further
     /// parsing of the table will be reported through this handler.
     /// \param UnrecoverableErrorHandler - any issues that prevent further
     /// parsing of the table will be reported through this handler.
     /// \param OS - if not null, the parser will print information about the
     /// table as it parses it.
+    /// \param Verbose - if true, the parser will print verbose information when
+    /// printing to the output.
     LineTable parseNext(function_ref<void(Error)> RecoverableErrorHandler,
                         function_ref<void(Error)> UnrecoverableErrorHandler,
-                        raw_ostream *OS = nullptr);
+                        raw_ostream *OS = nullptr, bool Verbose = false);
 
     /// Skip the current line table and go to the following line table (if
     /// present) immediately.
     ///
     /// \param RecoverableErrorHandler - report any recoverable prologue
     /// parsing issues via this handler.
     /// \param UnrecoverableErrorHandler - report any unrecoverable prologue
     /// parsing issues via this handler.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
                              Optional<uint64_t> DumpOffset) {
     while (!Parser.done()) {
       if (DumpOffset && Parser.getOffset() != *DumpOffset) {
         Parser.skip(DumpOpts.WarningHandler, DumpOpts.WarningHandler);
         continue;
       }
       OS << "debug_line[" << format("0x%8.8" PRIx64, Parser.getOffset())
          << "]\n";
-      if (DumpOpts.Verbose) {
-        Parser.parseNext(DumpOpts.WarningHandler, DumpOpts.WarningHandler, &OS);
-      } else {
-        DWARFDebugLine::LineTable LineTable =
-            Parser.parseNext(DumpOpts.WarningHandler, DumpOpts.WarningHandler);
-        LineTable.dump(OS, DumpOpts);
-      }
+      Parser.parseNext(DumpOpts.WarningHandler, DumpOpts.WarningHandler, &OS,
+                       DumpOpts.Verbose);
     }
   };
 
   if (const auto *Off = shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine,
                                    DObj->getLineSection().Data)) {
     DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(),
                                 0);
     DWARFDebugLine::SectionParser Parser(LineData, *this, compile_units(),

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

LineOffset =
         (AddrAdvanceResult.AdjustedOpcode % LineTable->Prologue.LineRange);
   Row.Line += LineOffset;
   return {AddrAdvanceResult.AddrDelta, LineOffset};
 }
 
 Error DWARFDebugLine::LineTable::parse(
     DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
     const DWARFContext &Ctx, const DWARFUnit *U,
-    function_ref<void(Error)> RecoverableErrorHandler, raw_ostream *OS) {
+    function_ref<void(Error)> RecoverableErrorHandler, raw_ostream *OS,
+    bool Verbose) {
+  assert((OS || !Verbose) && "cannot have verbose output without stream");
   const uint64_t DebugLineOffset = *OffsetPtr;
 
   clear();
 
   Error PrologueErr =
       Prologue.parse(DebugLineData, OffsetPtr, RecoverableErrorHandler, Ctx, U);
 
   if (OS) {
-    // The presence of OS signals verbose dumping.
     DIDumpOptions DumpOptions;
-    DumpOptions.Verbose = true;
+    DumpOptions.Verbose = Verbose;
     Prologue.dump(*OS, DumpOptions);
   }
 
   if (PrologueErr)
     return PrologueErr;
 
-  if (OS)
-    Row::dumpTableHeader(*OS, 12);
-
   uint64_t ProgramLength = Prologue.TotalLength + Prologue.sizeofTotalLength();
   if (!DebugLineData.isValidOffsetForDataOfSize(DebugLineOffset,
                                                 ProgramLength)) {
     assert(DebugLineData.size() > DebugLineOffset &&
            "prologue parsing should handle invalid offset");
     uint64_t BytesRemaining = DebugLineData.size() - DebugLineOffset;
     RecoverableErrorHandler(
         createStringError(errc::invalid_argument,
Error DWARFDebugLine::LineTable::parse(
   // See if we should tell the data extractor the address size.
   if (TableData.getAddressSize() == 0)
     TableData.setAddressSize(Prologue.getAddressSize());
   else
     assert(Prologue.getAddressSize() == 0 ||
            Prologue.getAddressSize() == TableData.getAddressSize());
 
   ParsingState State(this, DebugLineOffset, RecoverableErrorHandler);
+  bool HeaderPrinted = false;
 
   *OffsetPtr = DebugLineOffset + Prologue.getLength();
   while (*OffsetPtr < EndOffset) {
-    if (OS)
+    if (OS && !HeaderPrinted) {
+      *OS << "\n";
+      Row::dumpTableHeader(*OS, Verbose ? 12 : 0);
+      HeaderPrinted = true;
+    }
+
+    if (Verbose)
       *OS << format("0x%08.08" PRIx64 ": ", *OffsetPtr);
 
     uint64_t OpcodeOffset = *OffsetPtr;
     uint8_t Opcode = TableData.getU8(OffsetPtr);
 
-    if (OS)
+    if (Verbose)
       *OS << format("%02.02" PRIx8 " ", Opcode);
 
     if (Opcode == 0) {
       // Extended Opcodes always start with a zero opcode followed by
       // a uleb128 length so you can skip ones you don't know about
       uint64_t Len = TableData.getULEB128(OffsetPtr);
       uint64_t ExtOffset = *OffsetPtr;
 
       // Tolerate zero-length; assume length is correct and soldier on.
       if (Len == 0) {
-        if (OS)
+        if (Verbose)
           *OS << "Badly formed extended line op (length 0)\n";
         continue;
       }
 
       uint8_t SubOpcode = TableData.getU8(OffsetPtr);
-      if (OS)
+      if (Verbose)
         *OS << LNExtendedString(SubOpcode);
       switch (SubOpcode) {
       case DW_LNE_end_sequence:
         // Set the end_sequence register of the state machine to true and
         // append a row to the matrix using the current values of the
         // state-machine registers. Then reset the registers to the initial
         // values specified above. Every statement program sequence must end
         // with a DW_LNE_end_sequence instruction which creates a row whose
         // address is that of the byte after the last target machine instruction
         // of the sequence.
         State.Row.EndSequence = true;
-        if (OS) {
+        if (Verbose) {
           *OS << "\n";
           OS->indent(12);
-          State.Row.dump(*OS);
         }
+        if (OS)
+          State.Row.dump(*OS);
         State.appendRowToMatrix();
         State.resetRowAndSequence();
         break;
 
       case DW_LNE_set_address:
         // Takes a single relocatable address as an operand. The size of the
         // operand is the size appropriate to hold an address on the target
         // machine. Set the address register to the value given by the
if (Opcode == 0) {
             State.Row.Address.Address = TableData.getRelocatedAddress(
                 OffsetPtr, &State.Row.Address.SectionIndex);
 
             // Restore the address size if the extractor already had it.
             if (ExtractorAddressSize != 0)
               TableData.setAddressSize(ExtractorAddressSize);
           }
 
-          if (OS)
+          if (Verbose)
             *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
if (Opcode == 0) {
           FileNameEntry FileEntry;
           const char *Name = TableData.getCStr(OffsetPtr);
           FileEntry.Name =
               DWARFFormValue::createFromPValue(dwarf::DW_FORM_string, Name);
           FileEntry.DirIdx = TableData.getULEB128(OffsetPtr);
           FileEntry.ModTime = TableData.getULEB128(OffsetPtr);
           FileEntry.Length = TableData.getULEB128(OffsetPtr);
           Prologue.FileNames.push_back(FileEntry);
-          if (OS)
+          if (Verbose)
             *OS << " (" << Name << ", dir=" << FileEntry.DirIdx << ", mod_time="
                 << format("(0x%16.16" PRIx64 ")", FileEntry.ModTime)
                 << ", length=" << FileEntry.Length << ")";
         }
         break;
 
       case DW_LNE_set_discriminator:
         State.Row.Discriminator = TableData.getULEB128(OffsetPtr);
-        if (OS)
+        if (Verbose)
           *OS << " (" << State.Row.Discriminator << ")";
         break;
 
       default:
-        if (OS)
+        if (Verbose)
           *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 length as recorded in the table and the standard length
       // for the opcode match. If they don't, continue from the end as claimed
       // by the table.
       uint64_t End = ExtOffset + Len;
       if (*OffsetPtr != End) {
         RecoverableErrorHandler(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));
         *OffsetPtr = End;
       }
     } else if (Opcode < Prologue.OpcodeBase) {
-      if (OS)
+      if (Verbose)
         *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.
-        if (OS) {
+        if (Verbose) {
           *OS << "\n";
           OS->indent(12);
+        }
+        if (OS) {
           State.Row.dump(*OS);
-          *OS << "\n";
         }
+        if (Verbose) // FIXME: Don't print this newline.
+          *OS << "\n";
         State.appendRowToMatrix();
         break;
 
       case DW_LNS_advance_pc:
         // Takes a single unsigned LEB128 operand, multiplies it by the
         // min_inst_length field of the prologue, and adds the
         // result to the address register of the state machine.
         {
           uint64_t AddrOffset = State.advanceAddr(
               TableData.getULEB128(OffsetPtr), Opcode, OpcodeOffset);
-          if (OS)
+          if (Verbose)
             *OS << " (" << AddrOffset << ")";
         }
         break;
 
       case DW_LNS_advance_line:
         // Takes a single signed LEB128 operand and adds that value to
         // the line register of the state machine.
         State.Row.Line += TableData.getSLEB128(OffsetPtr);
-        if (OS)
+        if (Verbose)
           *OS << " (" << State.Row.Line << ")";
         break;
 
       case DW_LNS_set_file:
         // Takes a single unsigned LEB128 operand and stores it in the file
         // register of the state machine.
         State.Row.File = TableData.getULEB128(OffsetPtr);
-        if (OS)
+        if (Verbose)
           *OS << " (" << State.Row.File << ")";
         break;
 
       case DW_LNS_set_column:
         // Takes a single unsigned LEB128 operand and stores it in the
         // column register of the state machine.
         State.Row.Column = TableData.getULEB128(OffsetPtr);
-        if (OS)
+        if (Verbose)
           *OS << " (" << State.Row.Column << ")";
         break;
 
       case DW_LNS_negate_stmt:
         // Takes no arguments. Set the is_stmt register of the state
         // machine to the logical negation of its current value.
         State.Row.IsStmt = !State.Row.IsStmt;
         break;
if (Opcode == 0) {
         // twice the range of the last special opcode, it can use
         // DW_LNS_const_add_pc followed by a special opcode, for a total
         // of two bytes. Only if it needs to advance the address by more
         // than twice that range will it need to use both DW_LNS_advance_pc
         // and a special opcode, requiring three or more bytes.
         {
           uint64_t AddrOffset =
               State.advanceAddrForOpcode(Opcode, OpcodeOffset).AddrDelta;
-          if (OS)
+          if (Verbose)
             *OS << format(" (0x%16.16" PRIx64 ")", AddrOffset);
         }
         break;
 
       case DW_LNS_fixed_advance_pc:
         // Takes a single uhalf operand. Add to the address register of
         // the state machine the value of the (unencoded) operand. This
         // is the only extended opcode that takes an argument that is not
         // a variable length number. The motivation for DW_LNS_fixed_advance_pc
         // is this: existing assemblers cannot emit DW_LNS_advance_pc or
         // special opcodes because they cannot encode LEB128 numbers or
         // judge when the computation of a special opcode overflows and
         // requires the use of DW_LNS_advance_pc. Such assemblers, however,
         // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.
         {
           uint16_t PCOffset = TableData.getRelocatedValue(2, OffsetPtr);
           State.Row.Address.Address += PCOffset;
-          if (OS)
-            *OS
-                << format(" (0x%4.4" PRIx16 ")", PCOffset);
+          if (Verbose)
+            *OS << format(" (0x%4.4" PRIx16 ")", PCOffset);
         }
         break;
 
       case DW_LNS_set_prologue_end:
         // Takes no arguments. Set the prologue_end register of the
         // state machine to true
         State.Row.PrologueEnd = true;
         break;
 
       case DW_LNS_set_epilogue_begin:
         // Takes no arguments. Set the basic_block register of the
         // state machine to true
         State.Row.EpilogueBegin = true;
         break;
 
       case DW_LNS_set_isa:
         // Takes a single unsigned LEB128 operand and stores it in the
         // column register of the state machine.
         State.Row.Isa = TableData.getULEB128(OffsetPtr);
-        if (OS)
+        if (Verbose)
           *OS << " (" << (uint64_t)State.Row.Isa << ")";
         break;
 
       default:
         // Handle any unknown standard opcodes here. We know the lengths
         // of such opcodes because they are specified in the prologue
         // as a multiple of LEB128 operands for each opcode.
         {
           assert(Opcode - 1U < Prologue.StandardOpcodeLengths.size());
           uint8_t OpcodeLength = Prologue.StandardOpcodeLengths[Opcode - 1];
           for (uint8_t I = 0; I < OpcodeLength; ++I) {
             uint64_t Value = TableData.getULEB128(OffsetPtr);
-            if (OS)
+            if (Verbose)
               *OS << format("Skipping ULEB128 value: 0x%16.16" PRIx64 ")\n",
                             Value);
           }
         }
         break;
       }
     } else {
       // Special Opcodes.
       ParsingState::AddrAndLineDelta Delta =
           State.handleSpecialOpcode(Opcode, OpcodeOffset);
 
-      if (OS) {
+      if (Verbose) {
         *OS << "address += " << Delta.Address << ",  line += " << Delta.Line
             << "\n";
         OS->indent(12);
-        State.Row.dump(*OS);
       }
+      if (OS)
+        State.Row.dump(*OS);
 
       State.appendRowToMatrix();
     }
-    if(OS)
+    if(Verbose)
       *OS << "\n";
   }
 
   if (!State.Sequence.Empty)
     RecoverableErrorHandler(createStringError(
         errc::illegal_byte_sequence,
         "last sequence in debug line table at offset 0x%8.8" PRIx64
         " is not terminated",
         DebugLineOffset));
 
   // Sort all sequences so that address lookup will work faster.
   if (!Sequences.empty()) {
     llvm::sort(Sequences, Sequence::orderByHighPC);
     // Note: actually, instruction address ranges of sequences should not
     // overlap (in shared objects and executables). If they do, the address
     // lookup would still work, though, but result would be ambiguous.
     // We don't report warning in this case. For example,
     // sometimes .so compiled from multiple object files contains a few
     // rudimentary sequences for address ranges [0x0, 0xsomething).
   }
 
+  // Terminate the table with a final blank line to clearly delineate it from
+  // later dumps.
+  if (OS)
+    *OS << "\n";
+
   return Error::success();
 }
 
 uint32_t DWARFDebugLine::LineTable::findRowInSeq(
     const DWARFDebugLine::Sequence &Seq,
     object::SectionedAddress Address) const {
   if (!Seq.containsPC(Address))
     return UnknownRowIndex;

 }
 
 bool DWARFDebugLine::Prologue::totalLengthIsValid() const {
   return TotalLength != 0u;
 }
 
 DWARFDebugLine::LineTable DWARFDebugLine::SectionParser::parseNext(
     function_ref<void(Error)> RecoverableErrorHandler,
-    function_ref<void(Error)> UnrecoverableErrorHandler, raw_ostream *OS) {
+    function_ref<void(Error)> UnrecoverableErrorHandler, raw_ostream *OS, bool Verbose) {
   assert(DebugLineData.isValidOffset(Offset) &&
          "parsing should have terminated");
   DWARFUnit *U = prepareToParse(Offset);
   uint64_t OldOffset = Offset;
   LineTable LT;
   if (Error Err = LT.parse(DebugLineData, &Offset, Context, U,
-                           RecoverableErrorHandler, OS))
+                           RecoverableErrorHandler, OS, Verbose))
     UnrecoverableErrorHandler(std::move(Err));
   moveToNextTable(OldOffset, LT.Prologue);
   return LT;
 }
 
 void DWARFDebugLine::SectionParser::skip(
     function_ref<void(Error)> RecoverableErrorHandler,
     function_ref<void(Error)> UnrecoverableErrorHandler) {

llvm/test/tools/llvm-dwarfdump/X86/debug_line_dwarf64_large_table.s

 ## Test that we can dump the (intact) prologue of a large table which was
 ## truncated. Also, make sure we don't get confused by a DWARF64 length which
 ## matches one of the reserved initial length values.
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux %s >%t
 # RUN: llvm-dwarfdump %t -debug-line 2>&1 | FileCheck %s
 
 # CHECK: debug_line[0x00000000]
-# CHECK-NEXT: warning: line table program with offset 0x00000000 has length 0xfffffffc but only 0x0000003a bytes are available
 # CHECK-NEXT: Line table prologue:
 # CHECK-NEXT:     total_length: 0x00000000fffffff0
 # CHECK-NEXT:           format: DWARF64
 # CHECK-NEXT:          version: 4
 # CHECK-NEXT:  prologue_length: 0x0000000000000016
+# CHECK:        file_names[ 1]:
+# CHECK-NEXT:             name: "file1"
+# CHECK-NEXT:        dir_index: 0
+# CHECK-NEXT:         mod_time: 0x00000000
+# CHECK-NEXT:           length: 0x00000000
+# CHECK-NEXT: warning: line table program with offset 0x00000000 has length 0xfffffffc but only 0x0000003a bytes are available
 
 # CHECK:      0x000000000badbeef      1      0      1   0             0  is_stmt end_sequence
 
 .section .debug_line,"",@progbits
 .long   0xffffffff      # Length of Unit (DWARF-64 format)
 .quad   0xfffffff0
 .short  4               # DWARF version number
 .quad   .Lprologue1_end-.Lprologue1_start # Length of Prologue

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

 # RUN:   | FileCheck %s --check-prefixes=HEADER,FIRST,NOLATER,RESERVED
 
 ## Stop looking for the specified unit, if a fatally-bad prologue is detected.
 # RUN: llvm-dwarfdump -debug-line=0x4b %t-reserved.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefixes=HEADER,NOFIRST,NOLATER,RESERVED
 
 ## Show that non-fatal errors do not prevent parsing the rest of the section.
 # 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 \
-# RUN:   | FileCheck %s --check-prefixes=HEADER,FIRST,NONFATAL,LAST --implicit-check-not='debug_line[{{.*}}]'
-# 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 \
-# RUN:   | FileCheck %s --check-prefixes=HEADER,FIRST,VERBOSE,NONFATAL,LAST --implicit-check-not='debug_line[{{.*}}]' \
-# RUN:       --implicit-check-not=' DW_LNS' --implicit-check-not=' DW_LNE' --implicit-check-not='address +='
-# RUN: FileCheck %s --input-file=%t-malformed-verbose.err --check-prefixes=ALL,OTHER
+# RUN: llvm-dwarfdump -debug-line %t-malformed.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefixes=HEADER,FIRST,NONFATAL,LAST,SOME-ERR,MORE-ERR \
+# RUN:       --implicit-check-not='debug_line[{{.*}}]' --implicit-check-not='warning:'
+# RUN: llvm-dwarfdump -debug-line %t-malformed.o -verbose 2>&1 \
+# RUN:   | FileCheck %s --check-prefixes=HEADER,FIRST,VERBOSE,NONFATAL,LAST,SOME-ERR,MORE-ERR \
+# RUN:       --implicit-check-not='debug_line[{{.*}}]' --implicit-check-not=' DW_LNS' \
+# RUN:       --implicit-check-not=' DW_LNE' --implicit-check-not='address +=' \
+# RUN:       --implicit-check-not='warning:'
 
 ## We should still produce warnings for malformed tables after the specified unit.
-# RUN: llvm-dwarfdump -debug-line=0 %t-malformed.o 2> %t-malformed-off-first.err \
-# RUN:   | FileCheck %s --check-prefixes=HEADER,FIRST,NOLATER
-# RUN: FileCheck %s --input-file=%t-malformed-off-first.err --check-prefix=ALL
+# RUN: llvm-dwarfdump -debug-line=0 %t-malformed.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefixes=HEADER,FIRST,NOLATER,SOME-ERR --implicit-check-not='warning:'
 
 ## Don't stop looking for the later unit if non-fatal issues are found.
-# RUN: llvm-dwarfdump -debug-line=0x419 %t-malformed.o 2> %t-malformed-off-last.err \
-# RUN:   | FileCheck %s --check-prefixes=HEADER,LAST --implicit-check-not='debug_line[{{.*}}]'
-# RUN: FileCheck %s --input-file=%t-malformed-off-last.err --check-prefix=ALL
+# RUN: llvm-dwarfdump -debug-line=0x419 %t-malformed.o 2>&1 \
+# RUN:   | FileCheck %s --check-prefixes=HEADER,LAST,SOME-ERR --implicit-check-not='debug_line[{{.*}}]' \
+# RUN:       --implicit-check-not='warning:'
 
 # HEADER:       .debug_line contents:
 
 # FIRST:        debug_line[0x00000000]
 # VERBOSE:                  Address            Line   Column File   ISA Discriminator Flags
 # VERBOSE-NEXT:             ------------------ ------ ------ ------ --- ------------- -------------
 # VERBOSE-NEXT: DW_LNE_set_address (0x000000000badbeef)
 # VERBOSE-NEXT: DW_LNE_end_sequence
 # FIRST:        0x000000000badbeef {{.*}} end_sequence
+# FIRST-EMPTY:
 # 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:
 # FATAL:      debug_line[0x00000048]
 # RESERVED-NOT: prologue
 # RESERVED: warning: parsing line table prologue at offset 0x00000048: unsupported reserved unit length of value 0xfffffffe
 # RESERVED-NOT: prologue
 # FATAL-NOT:  debug_line
 
 ## For non-fatal issues, the table data should be dumped:
 
 ## Version 0 table.
 # NONFATAL:      debug_line[0x00000048]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL-NEXT:    total_length: 0x00000002
 # NONFATAL-NEXT:          format: DWARF32
 # NONFATAL-NEXT:         version: 0
+# SOME-ERR-NEXT: warning: parsing line table prologue at offset 0x00000048: unsupported version 0
 # NONFATAL-NOT: prologue_length
 
 ## Version 1 table.
 # NONFATAL:      debug_line[0x0000004e]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL-NEXT:    total_length: 0x00000002
 # NONFATAL-NEXT:          format: DWARF32
 # NONFATAL-NEXT:         version: 1
+# SOME-ERR-NEXT: warning: parsing line table prologue at offset 0x0000004e: unsupported version 1
 # NONFATAL-NOT: prologue_length
 
 ## Malformed directory format with no path component.
 # NONFATAL:      debug_line[0x00000054]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x00000054 found an invalid directory or file table description at 0x00000073
+# SOME-ERR-NEXT: warning: failed to parse entry content descriptions because no path was found
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      prologue_length: 0x00000013
 # NONFATAL-NOT:  include_directories
 # NONFATAL-NOT:  file_names
 # VERBOSE:       DW_LNE_set_address (0x8877665544332211)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## Prologue with length shorter than parsed.
 # NONFATAL:      debug_line[0x00000081]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x00000081 found an invalid directory or file table description at 0x000000ba
+# SOME-ERR-NEXT: warning: file names table was not null terminated before the end of the prologue
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      file_names[  1]:
 # NONFATAL-NEXT:            name: "file1"
 # NONFATAL-NEXT:       dir_index: 1
 # NONFATAL-NEXT:        mod_time: 0x00000002
 # NONFATAL-NEXT:          length: 0x00000003
 # VERBOSE:       DW_LNS_negate_stmt
 # VERBOSE-NEXT:  DW_LNE_set_address (0x1122334455667788)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## Prologue with length longer than parsed.
 # NONFATAL:      debug_line[0x000000c8]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x000000c8 should have ended at 0x00000103 but it ended at 0x00000102
 # 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
 # VERBOSE:       DW_LNE_set_address (0x1111222233334444)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## Extended opcode with incorrect length versus expected.
 # NONFATAL:      debug_line[0x00000111]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      prologue_length: 0x00000030
 # VERBOSE:       DW_LNE_set_address (0x00000000abbadaba)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
+# MORE-ERR:      warning: unexpected line op length at offset 0x00000158 expected 0x02 found 0x01
 # VERBOSE:       DW_LNE_set_discriminator (10)
-# VERBOSE-NEXT:  DW_LNS_set_prologue_end
+# MORE-ERR:      warning: unexpected line op length at offset 0x0000015c expected 0x01 found 0x02
+# VERBOSE:       DW_LNS_set_prologue_end
 # VERBOSE-NEXT:  DW_LNE_set_address (0x00000000babb1e45)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## No end of sequence.
 # NONFATAL:      debug_line[0x0000016c]
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      prologue_length: 0x00000030
 # VERBOSE:       DW_LNE_set_address (0x00000000deadfade)
 # VERBOSE-NEXT:  DW_LNS_copy
+# MORE-ERR:      warning: last sequence in debug line table at offset 0x0000016c is not terminated
 
 ## Very short prologue length for V5 (ends during parameters).
 # NONFATAL:      debug_line[0x000001b2]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x000001b2 should have ended at 0x000001ce but it ended at 0x000001e1
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      standard_opcode_lengths[DW_LNS_set_isa] = 1
 # NONFATAL-NEXT: include_directories[  0] = "/tmp"
 # NONFATAL-NEXT: file_names[  0]:
 # NONFATAL-NEXT:            name: "xyz"
 # VERBOSE:       DW_LNE_end_sequence
 # VERBOSE:       DW_LNS_copy
 # VERBOSE:       DW_LNS_const_add_pc (0x0000000000000011)
 # VERBOSE-NEXT:  DW_LNS_copy
 # VERBOSE:       address += 2, line += 1
 # VERBOSE:       address += 7, line += 0
 # VERBOSE:       address += 6, line += 7
 # VERBOSE:       address += 7, line += -4
 # VERBOSE:       DW_LNE_end_sequence
 # VERBOSE:       DW_LNS_const_add_pc (0x0000000000000011)
 # VERBOSE-NEXT:  DW_LNS_copy
 # VERBOSE:       address += 7, line += 4
 # VERBOSE:       address += 7, line += 5
 # VERBOSE:       address += 7, line += 6
 # VERBOSE:       DW_LNE_set_address (0x0000babb1ebabb1e)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## V5 prologue ends during file table.
 # NONFATAL:      debug_line[0x000001ee]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x000001ee should have ended at 0x00000219 but it ended at 0x00000220
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  0] = "/tmp"
 # NONFATAL-NEXT: file_names[  0]:
 # NONFATAL-NEXT:            name: "xyz"
 # NONFATAL-NEXT:       dir_index: 1
 # VERBOSE:       DW_LNS_set_epilogue_begin
 # VERBOSE-NEXT:  DW_LNS_copy
 # VERBOSE:       address += 7, line += 4
 # VERBOSE:       address += 7, line += 5
 # VERBOSE:       address += 7, line += 6
 # VERBOSE:       DW_LNE_end_sequence
 # VERBOSE:       DW_LNE_set_address (0x00000ab4acadab4a)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## V5 prologue ends during directory table.
 # NONFATAL:      debug_line[0x0000022f]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x0000022f should have ended at 0x00000251 but it ended at 0x0000025e
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  0] = "/tmp"
 # NONFATAL-NEXT: file_names[  0]:
 # NONFATAL-NEXT:            name: "xyz"
 # VERBOSE:       address += 2, line += 1
 # VERBOSE:       address += 7, line += 0
 # VERBOSE:       address += 6, line += 7
 # VERBOSE:       address += 7, line += -4
 # VERBOSE:       DW_LNE_end_sequence
 # VERBOSE:       DW_LNS_const_add_pc (0x0000000000000011)
 # VERBOSE-NEXT:  DW_LNS_copy
 # VERBOSE:       address += 7, line += 4
 # VERBOSE:       address += 7, line += 5
 # VERBOSE:       address += 7, line += 6
 # VERBOSE:       DW_LNE_set_address (0x4444333322221111)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## V5 invalid MD5 hash form when there is still data to be read.
 # NONFATAL:      debug_line[0x0000026b]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x0000026b found an invalid directory or file table description at 0x0000029f
+# SOME-ERR-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  0] = "/tmp"
 # NONFATAL-NOT:  file_names
 # VERBOSE:       DW_LNE_set_address (0x1234123412341234)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## V5 invalid MD5 hash form when data beyond the prologue length has
 ## been read before the MD5 problem is identified.
 # NONFATAL:      debug_line[0x000002ae]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x000002ae found an invalid directory or file table description at 0x000002e0
+# SOME-ERR-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  0] = "/tmp"
 # NONFATAL-NOT:  file_names
 # VERBOSE:       DW_LNS_set_epilogue_begin
 # VERBOSE-NEXT:  DW_LNS_copy
 # VERBOSE:       address += 7, line += 4
 # VERBOSE:       address += 7, line += 5
 # VERBOSE:       address += 7, line += 6
 # VERBOSE:       DW_LNE_set_address (0x4321432143214321)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## V5 invalid directory content description has unsupported form.
 # NONFATAL:      debug_line[0x000002ec]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x000002ec found an invalid directory or file table description at 0x00000315
+# SOME-ERR-NEXT: warning: failed to parse directory entry because skipping the form value failed.
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  0] = "/foo"
 # NONFATAL-NOT:  include_directories
 # NONFATAL-NOT:  file_names
 # VERBOSE:       DW_LNE_set_address (0xaaaabbbbccccdddd)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## Opcode base field of value zero.
 # NONFATAL:      debug_line[0x00000332]
+# SOME-ERR-NEXT: warning: parsing line table prologue at offset 0x00000332 found opcode base of 0. Assuming no standard opcodes
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  1] = "dir1"
 # NONFATAL-NEXT: file_names[  1]:
 # NONFATAL-NEXT:            name: "file1"
 # NONFATAL-NEXT:       dir_index: 1
 # NONFATAL-NEXT:        mod_time: 0x00000002
 # NONFATAL-NEXT:          length: 0x00000003
 # VERBOSE:       DW_LNE_set_address (0xffffeeeeddddcccc)
 # VERBOSE-NEXT:  address += 1, line += 0
 # VERBOSE:       DW_LNE_end_sequence
 
 ## V4 table with unterminated include directory table.
 # NONFATAL:      debug_line[0x00000361]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x00000361 found an invalid directory or file table description at 0x00000383
+# SOME-ERR-NEXT: warning: include directories table was not null terminated before the end of the prologue
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      include_directories[  1] = "dir1"
 # NONFATAL-NOT:  file_names
 # VERBOSE:       DW_LNE_set_address (0xabcdef0123456789)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## V4 table with unterminated file name table.
 # NONFATAL:      debug_line[0x00000390]
+# SOME-ERR-NEXT: warning: parsing line table prologue at 0x00000390 found an invalid directory or file table description at 0x000003bf
+# SOME-ERR-NEXT: warning: file names table was not null terminated before the end of the prologue
 # NONFATAL-NEXT: Line table prologue
 # NONFATAL:      file_names[  1]:
 # NONFATAL-NEXT:            name: "foo.c"
 # NONFATAL-NEXT:       dir_index: 1
 # NONFATAL-NEXT:        mod_time: 0x00000002
 # NONFATAL-NEXT:          length: 0x00000003
 # NONFATAL-NOT:  file_names
 # VERBOSE:       DW_LNE_set_address (0xababcdcdefef0909)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
 
 ## Table with extended opcode that overruns table end.
 # NONFATAL:      debug_line[0x000003c9]
 # NONFATAL-NEXT: Line table prologue
 # VERBOSE:       DW_LNE_set_address (0x00000000feedfeed)
 # VERBOSE-NEXT:  DW_LNS_copy
 # VERBOSE:       DW_LNE_set_address (0x0000000000000000)
+# MORE-ERR:      warning: unexpected line op length at offset 0x00000411 expected 0x09 found 0x01
+# MORE-ERR:      warning: last sequence in debug line table at offset 0x000003c9 is not terminated
 
 # LAST:          debug_line[0x00000419]
 # VERBOSE:       DW_LNE_set_address (0x00000000cafebabe)
 # VERBOSE-NEXT:  DW_LNE_end_sequence
-
-# ALL-NOT:  warning:
-# ALL:      warning: parsing line table prologue at offset 0x00000048: unsupported version 0
-# ALL-NEXT: warning: parsing line table prologue at offset 0x0000004e: unsupported version 1
-# ALL-NEXT: warning: parsing line table prologue at 0x00000054 found an invalid directory or file table description at 0x00000073
-# ALL-NEXT: warning: failed to parse entry content descriptions because no path was found
-# ALL-NEXT: warning: parsing line table prologue at 0x00000081 found an invalid directory or file table description at 0x000000ba
-# ALL-NEXT: warning: file names table was not null terminated before the end of the prologue
-# ALL-NEXT: warning: parsing line table prologue at 0x000000c8 should have ended at 0x00000103 but it ended at 0x00000102
-# OTHER-NEXT: warning: unexpected line op length at offset 0x00000158 expected 0x02 found 0x01
-# OTHER-NEXT: warning: unexpected line op length at offset 0x0000015c expected 0x01 found 0x02
-# OTHER-NEXT: warning: last sequence in debug line table at offset 0x0000016c is not terminated
-# ALL-NEXT: warning: parsing line table prologue at 0x000001b2 should have ended at 0x000001ce but it ended at 0x000001e1
-# ALL-NEXT: warning: parsing line table prologue at 0x000001ee should have ended at 0x00000219 but it ended at 0x00000220
-# ALL-NEXT: warning: parsing line table prologue at 0x0000022f should have ended at 0x00000251 but it ended at 0x0000025e
-# ALL-NEXT: warning: parsing line table prologue at 0x0000026b found an invalid directory or file table description at 0x0000029f
-# ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
-# ALL-NEXT: warning: parsing line table prologue at 0x000002ae found an invalid directory or file table description at 0x000002e0
-# ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
-# ALL-NEXT: warning: parsing line table prologue at 0x000002ec found an invalid directory or file table description at 0x00000315
-# ALL-NEXT: warning: failed to parse directory entry because skipping the form value failed.
-# ALL-NEXT: warning: parsing line table prologue at offset 0x00000332 found opcode base of 0. Assuming no standard opcodes
-# ALL-NEXT: warning: parsing line table prologue at 0x00000361 found an invalid directory or file table description at 0x00000383
-# ALL-NEXT: warning: include directories table was not null terminated before the end of the prologue
-# ALL-NEXT: warning: parsing line table prologue at 0x00000390 found an invalid directory or file table description at 0x000003bf
-# ALL-NEXT: warning: file names table was not null terminated before the end of the prologue
-# OTHER-NEXT: warning: unexpected line op length at offset 0x00000411 expected 0x09 found 0x01
-# OTHER-NEXT: warning: last sequence in debug line table at offset 0x000003c9 is not terminated
-# ALL-NOT:  warning:

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

 # RUN: llvm-mc %S/brief.s -filetype obj -triple x86_64-apple-darwin -o %t.o
 # RUN: llvm-dwarfdump -v --debug-info --debug-line %t.o | \
-# RUN:   FileCheck %s --match-full-lines --strict-whitespace --dump-input=always
+# RUN:   FileCheck %s --match-full-lines --strict-whitespace
 
 #   CHECK-NOT:{{.*}} contents:
 
 #       CHECK:.debug_info contents:
 #       CHECK:0x0000000b: DW_TAG_compile_unit [1] *
 #       CHECK:              DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000037] = "brief.c")
 #       CHECK:0x0000002a:   DW_TAG_subprogram [2]  
 #       CHECK:                DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000004c] = "main")
 #       CHECK:0x00000043:   DW_TAG_base_type [3]  
 #  CHECK-NEXT:                DW_AT_name [DW_FORM_strp] ( .debug_str[0x{{.*}}] = "int")
 
 #       CHECK:.debug_line contents:
 #       CHECK:         length: 0x00000000
+# CHECK-EMPTY:
 #  CHECK-NEXT:            Address            Line   Column File   ISA Discriminator Flags
 #  CHECK-NEXT:            ------------------ ------ ------ ------ --- ------------- -------------
 #  CHECK-NEXT:0x00000029: 00 DW_LNE_set_address (0x0000000000000000)
 #  CHECK-NEXT:0x00000034: 01 DW_LNS_copy
 #  CHECK-NEXT:            0x0000000000000000      1      0      1   0             0  is_stmt
 # CHECK-EMPTY:
 # CHECK-EMPTY:
 #       CHECK:0x00000035: 05 DW_LNS_set_column (12)

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

TEST_F(DebugLineBasicFixture, ParserPrintsStandardOpcodesWhenRequested) {
   LT.addStandardOpcode(DW_LNS_set_epilogue_begin, {});
   LT.addStandardOpcode(DW_LNS_set_isa, {ValLen{66, LineTable::ULEB}});
   LT.addExtendedOpcode(1, DW_LNE_end_sequence, {});
   generate();
 
   DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs);
   std::string Output;
   raw_string_ostream OS(Output);
-  Parser.parseNext(RecordRecoverable, RecordUnrecoverable, &OS);
+  Parser.parseNext(RecordRecoverable, RecordUnrecoverable, &OS,
+                   /*Verbose=*/true);
   OS.flush();
 
   EXPECT_FALSE(Recoverable);
   EXPECT_FALSE(Unrecoverable);
   auto InOutput = [&Output](char const *Str) {
     return Output.find(Str) != std::string::npos;
   };
   EXPECT_TRUE(InOutput("0x0000002e: 01 DW_LNS_copy\n")) << Output;