Add line table verification to lldb-dwarfdump --verify. AbandonedPublic

[clayborg]

Summary

This patch verifies the .debug_line:

• verify all addresses in a line table sequence have ascending addresses
• verify that all line table file indexes are valid

Unit tests added for both cases.

[clayborg]

David: I took care of all your requests from the previous patch in this one.

[clayborg]

Woops, nice copy and paste error in the title. Sorry about that. Phabricator is getting worse for copy and paste these days...

[clayborg]

Paul: A future patch will add verification of unique DW_AT_stmt_list values and for verifying that all lines entries are in the CU ranges. I need to get another patch in before I do this as this other patch keeps track of all DW_TAG_subprogram address ranges, CU ranges, and verifies all DW_TAG_lexical_block and DW_TAG_inlined_subroutine are contained in their parents. Once I get that in, I can then verify each row address is found in the CU ranges (if available) and also agains the .debug_aranges (if available).

[probinson]

Following up on my comment in the other review:

In D32754#743907, @clayborg wrote:

In D32754#743899, @probinson wrote:

Can you verify that each CU (that has DW_AT_stmt_list) points to a different place in .debug_line?

That is a good idea. Maybe we emit a warning? I say that because it seems like a good way to save space for type unique style DWARF to share line tables since they only use the line tables for DW_AT_decl_file and DW_AT_call_file. Is it against the DWARF spec to share a line table? Let me know if you think this should be a warning or error.

A type unit can certainly point to the same line table as its CU; but type units are not themselves CUs. (In v4 they are in .debug_types not .debug_info, while in v5 they have a distinct unit-type code, so the verifier can easily tell them apart.) So the uniqueness check should not apply to TUs.

I am hard-pressed to imagine a situation where two CUs could reasonably share a line table. In a split-DWARF package file, there is no actual line table, but sharing the directory/file tables implies a coherent use of file/directory numbers across two CUs, or the packager rewriting the CUs to make them consistent, which is *really* hard to justify.

So, unless somebody can come up with a solid use-case, I'd say it should be an error for two CUs to have the same DW_AT_stmt_list offset. (Maybe this should be in the .debug_info verification instead of the line-table verification, though.)

[probinson]

In D32765#743931, @clayborg wrote:

Paul: A future patch will add verification of unique DW_AT_stmt_list values and for verifying that all lines entries are in the CU ranges. I need to get another patch in before I do this as this other patch keeps track of all DW_TAG_subprogram address ranges, CU ranges, and verifies all DW_TAG_lexical_block and DW_TAG_inlined_subroutine are contained in their parents. Once I get that in, I can then verify each row address is found in the CU ranges (if available) and also agains the .debug_aranges (if available).

Awesome, thanks!

[clayborg]

So, unless somebody can come up with a solid use-case, I'd say it should be an error for two CUs to have the same DW_AT_stmt_list offset. (Maybe this should be in the .debug_info verification instead of the line-table verification, though.)

I can add the unique DW_AT_stmt_list to this patch then. I will save the range one for later.

[dblaikie]

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

1668–1671

Presumably 'verify' should be const? (& then this parameter can be const as well)

[clayborg]

Paul: I will submit a follow up patch for the DW_AT_stmt_list not being found multiple times since this patch is accepted.

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

1671

It shouldn't be const because it can cause all compile units to be parsed, all DIEs in each CU to be parsed, any number of DWARFXXX classes to be created.

[probinson]

In D32765#743963, @clayborg wrote:

Paul: I will submit a follow up patch for the DW_AT_stmt_list not being found multiple times since this patch is accepted.

WFM.

include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

public:
   /// Standard .debug_line state machine structure.
   struct Row {
     explicit Row(bool DefaultIsStmt = false);
 
     /// Called after a row is appended to the matrix.
     void postAppend();
     void reset(bool DefaultIsStmt);
     void dump(raw_ostream &OS) const;
-
+    static void dumpTableHeader(raw_ostream &OS);
     static bool orderByAddress(const Row &LHS, const Row &RHS) {
       return LHS.Address < RHS.Address;
     }
 
     /// The program-counter value corresponding to a machine instruction
     /// generated by the compiler.
     uint64_t Address;
     /// An unsigned integer indicating a source line number. Lines are numbered

lib/DebugInfo/DWARF/DWARFContext.cpp

for (auto Pair: ReferenceToDIEOffsets) {
         auto ReferencingDie = DCtx.getDIEForOffset(Offset);
         ReferencingDie.dump(OS, 0);
         OS << "\n";
       }
       OS << "\n";
     }
     return Success;
   }
+
+  bool HandleDebugLine() {
+    bool Success = true;
+    OS << "Verifying .debug_line...\n";
+    for (const auto &CU : DCtx.compile_units()) {
+      uint32_t LineTableOffset = 0;
+      auto StmtFormValue = CU->getUnitDIE().find(DW_AT_stmt_list);
+      if (!StmtFormValue) {
+        // No line table for this compile unit.
+        continue;
+      }
+      // Get the attribute value as a section offset. No need to produce an
+      // error here if the encoding isn't correct because we validate this in
+      // the .debug_info verifier.
+      if (auto StmtSectionOffset = toSectionOffset(StmtFormValue)) {
+        LineTableOffset = *StmtSectionOffset;
+        if (LineTableOffset >= DCtx.getLineSection().Data.size()) {
+          // Make sure we don't get a valid line table back if the offset
+          // is wrong.
+          assert(DCtx.getLineTableForUnit(CU.get()) == nullptr);
+          // Skip this line table as it isn't valid. No need to create an error
+          // here because we validate this in the .debug_info verifier.
+          continue;
+        }
+      }
+      auto LineTable = DCtx.getLineTableForUnit(CU.get());
+      if (!LineTable) {
+        Success = false;
+        OS << "error: .debug_line[" << format("0x%08" PRIx32, LineTableOffset)
+           << "] was not able to be parsed for CU:\n";
+        CU->getUnitDIE().dump(OS, 0);
+        OS << '\n';
+        continue;
+      }
+      uint32_t MaxFileIndex = LineTable->Prologue.FileNames.size();
+      uint64_t PrevAddress = 0;
+      uint32_t RowIndex = 0;
+      for (const auto &Row : LineTable->Rows) {
+        if (Row.Address < PrevAddress) {
+          Success = false;
+          OS << "error: .debug_line[" << format("0x%08" PRIx32, LineTableOffset)
+             << "] row[" << RowIndex
+             << "] decreases in address from previous row:\n";
+
+          DWARFDebugLine::Row::dumpTableHeader(OS);
+          if (RowIndex > 0)
+            LineTable->Rows[RowIndex - 1].dump(OS);
+          Row.dump(OS);
+          OS << '\n';
+        }
+
+        if (Row.File > MaxFileIndex) {
+          Success = false;
+          OS << "error: .debug_line[" << format("0x%08" PRIx32, LineTableOffset)
+             << "][" << RowIndex << "] has invalid file index " << Row.File
+             << " (valid values are [1," << MaxFileIndex << "]):\n";
+          DWARFDebugLine::Row::dumpTableHeader(OS);
+          Row.dump(OS);
+          OS << '\n';
+        }
+        if (Row.EndSequence)
+          PrevAddress = 0;
+        else
+          PrevAddress = Row.Address;
+        ++RowIndex;
+      }
+    }
+    return Success;
+  }
 };
   
 } // anonymous namespace
 
 bool DWARFContext::verify(raw_ostream &OS, DIDumpType DumpType) {
   bool Success = true;
   Verifier verifier(OS, *this);
   if (DumpType == DIDT_All || DumpType == DIDT_Info) {
     if (!verifier.HandleDebugInfo())
       Success = false;
   }
+  if (DumpType == DIDT_All || DumpType == DIDT_Line) {
+    if (!verifier.HandleDebugLine())
+      Success = false;
+  }
   return Success;
 }
 const DWARFUnitIndex &DWARFContext::getCUIndex() {
   if (CUIndex)
     return *CUIndex;
 
   DataExtractor CUIndexData(getCUIndexSection(), isLittleEndian(), 0);
 

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

void DWARFDebugLine::Row::reset(bool DefaultIsStmt) {
   Discriminator = 0;
   IsStmt = DefaultIsStmt;
   BasicBlock = false;
   EndSequence = false;
   PrologueEnd = false;
   EpilogueBegin = false;
 }
 
+void DWARFDebugLine::Row::dumpTableHeader(raw_ostream &OS) {
+  OS << "Address            Line   Column File   ISA Discriminator Flags\n"
+     << "------------------ ------ ------ ------ --- ------------- "
+        "-------------\n";
+}
+
 void DWARFDebugLine::Row::dump(raw_ostream &OS) const {
   OS << format("0x%16.16" PRIx64 " %6u %6u", Address, Line, Column)
      << format(" %6u %3u %13u ", File, Isa, Discriminator)
      << (IsStmt ? " is_stmt" : "") << (BasicBlock ? " basic_block" : "")
      << (PrologueEnd ? " prologue_end" : "")
      << (EpilogueBegin ? " epilogue_begin" : "")
      << (EndSequence ? " end_sequence" : "") << '\n';
 }

 
 DWARFDebugLine::LineTable::LineTable() { clear(); }
 
 void DWARFDebugLine::LineTable::dump(raw_ostream &OS) const {
   Prologue.dump(OS);
   OS << '\n';
 
   if (!Rows.empty()) {
-    OS << "Address            Line   Column File   ISA Discriminator Flags\n"
-       << "------------------ ------ ------ ------ --- ------------- "
-          "-------------\n";
+    Row::dumpTableHeader(OS);
     for (const Row &R : Rows) {
       R.dump(OS);
     }
   }
 }
 
 void DWARFDebugLine::LineTable::clear() {
   Prologue.clear();

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

 //===- llvm/unittest/DebugInfo/DWARFFormValueTest.cpp ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfGenerator.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/Object/ObjectFile.h"
-#include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/DWARFEmitter.h"
+#include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gtest/gtest.h"
 #include <climits>
 #include <cstdint>
 #include <cstring>
const char *yamldata = "debug_abbrev:\n"
                          "    Entries:\n"
                          "      - AbbrCode:        0x00000001\n"
                          "        Values:\n"
                          "      - AbbrCode:        0x00000000\n"
                          "        Values:\n";
 
   auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
-
-  auto &DebugSections = *ErrOrSections;
-
-  DWARFContextInMemory DwarfContext(DebugSections, 8);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
 
   // Verify the number of compile units is correct.
   uint32_t NumCUs = DwarfContext.getNumCompileUnits();
   EXPECT_EQ(NumCUs, 1u);
   DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
 
   // Get the compile unit DIE is valid.
   auto CUDie = U->getUnitDIE(false);
TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
   EXPECT_EQ(DIEs.count(Val1), 2u);
   EXPECT_EQ(DIEs.count(Val2), 1u);
   auto Val1Range = DIEs.equal_range(Val1);
   for (auto it = Val1Range.first; it != Val1Range.second; ++it)
     EXPECT_EQ(it->second, AbbrevPtrVal1);
   EXPECT_EQ(DIEs.find(Val2)->second, AbbrevPtrVal2);
 }
 
+void VerifyError(DWARFContext &DwarfContext, StringRef Error) {
+  SmallString<1024> Str;
+  raw_svector_ostream Strm(Str);
+  EXPECT_FALSE(DwarfContext.verify(Strm, DIDT_All));
+  EXPECT_TRUE(Str.str().contains(Error));
+}
+
 TEST(DWARFDebugInfo, TestDwarfVerifyInvalidCURef) {
   // Create a single compile unit with a single function that has a DW_AT_type
   // that is CU relative. The CU offset is not valid becuase it is larger than
   // the compile unit itself.
 
   const char *yamldata = R"(
     debug_str:
       - ''
debug_info:
             Values:
               - Value:           0x000000000000000D
               - Value:           0x0000000000001234
           - AbbrCode:        0x00000000
             Values:
   )";
   auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
-
-  auto &DebugSections = *ErrOrSections;
-
-  DWARFContextInMemory DwarfContext(DebugSections, 8);
-
-  std::string str;
-  raw_string_ostream strm(str);
-  EXPECT_FALSE(DwarfContext.verify(strm, DIDT_All));
-  const char *err = "error: DW_FORM_ref4 CU offset 0x00001234 is invalid "
-                    "(must be less than CU size of 0x0000001a):";
-  EXPECT_TRUE(strm.str().find(err) != std::string::npos);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(DwarfContext, "error: DW_FORM_ref4 CU offset 0x00001234 is "
+                            "invalid (must be less than CU size of "
+                            "0x0000001a):");
 }
 
 TEST(DWARFDebugInfo, TestDwarfVerifyInvalidRefAddr) {
   // Create a single compile unit with a single function that has an invalid
   // DW_AT_type with an invalid .debug_info offset in its DW_FORM_ref_addr.
   const char *yamldata = R"(
     debug_str:
       - ''
debug_info:
             Values:
               - Value:           0x000000000000000D
               - Value:           0x0000000000001234
           - AbbrCode:        0x00000000
             Values:
   )";
   auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
-
-  auto &DebugSections = *ErrOrSections;
-
-  DWARFContextInMemory DwarfContext(DebugSections, 8);
-
-  std::string str;
-  raw_string_ostream strm(str);
-  EXPECT_FALSE(DwarfContext.verify(strm, DIDT_All));
-  strm.flush();
-  const char *err = "error: DW_FORM_ref_addr offset beyond .debug_info bounds:";
-  EXPECT_TRUE(strm.str().find(err) != std::string::npos);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(DwarfContext,
+              "error: DW_FORM_ref_addr offset beyond .debug_info bounds:");
 }
 
 TEST(DWARFDebugInfo, TestDwarfVerifyInvalidRanges) {
   // Create a single compile unit with a DW_AT_ranges whose section offset
   // isn't valid.
   const char *yamldata = R"(
     debug_str:
       - ''
debug_info:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000001000
 
   )";
   auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
-
-  auto &DebugSections = *ErrOrSections;
-
-  DWARFContextInMemory DwarfContext(DebugSections, 8);
-
-  std::string str;
-  raw_string_ostream strm(str);
-  EXPECT_FALSE(DwarfContext.verify(strm, DIDT_All));
-  strm.flush();
-  const char *err = "error: DW_AT_ranges offset is beyond .debug_ranges "
-                    "bounds:";
-  EXPECT_TRUE(strm.str().find(err) != std::string::npos);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(DwarfContext,
+              "error: DW_AT_ranges offset is beyond .debug_ranges bounds:");
 }
 
 TEST(DWARFDebugInfo, TestDwarfVerifyInvalidStmtList) {
   // Create a single compile unit with a DW_AT_stmt_list whose section offset
   // isn't valid.
   const char *yamldata = R"(
     debug_str:
       - ''
debug_info:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000001000
 
   )";
   auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
-
-  auto &DebugSections = *ErrOrSections;
-
-  DWARFContextInMemory DwarfContext(DebugSections, 8);
-
-  std::string str;
-  raw_string_ostream strm(str);
-  EXPECT_FALSE(DwarfContext.verify(strm, DIDT_All));
-  strm.flush();
-  const char *err = "error: DW_AT_stmt_list offset is beyond .debug_line "
-                    "bounds: 0x00001000";
-  EXPECT_TRUE(strm.str().find(err) != std::string::npos);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(
+      DwarfContext,
+      "error: DW_AT_stmt_list offset is beyond .debug_line bounds: 0x00001000");
 }
 
 TEST(DWARFDebugInfo, TestDwarfVerifyInvalidStrp) {
   // Create a single compile unit with a single function that has an invalid
   // DW_FORM_strp for the DW_AT_name.
   const char *yamldata = R"(
     debug_str:
       - ''
debug_info:
         AddrSize:        8
         Entries:
           - AbbrCode:        0x00000001
             Values:
               - Value:           0x0000000000001234
   )";
   auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
-
-  auto &DebugSections = *ErrOrSections;
-
-  DWARFContextInMemory DwarfContext(DebugSections, 8);
-
-  std::string str;
-  raw_string_ostream strm(str);
-  EXPECT_FALSE(DwarfContext.verify(strm, DIDT_All));
-  strm.flush();
-  const char *err = "error: DW_FORM_strp offset beyond .debug_str bounds:";
-  EXPECT_TRUE(strm.str().find(err) != std::string::npos);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(DwarfContext,
+              "error: DW_FORM_strp offset beyond .debug_str bounds:");
 }
 
 TEST(DWARFDebugInfo, TestDwarfVerifyInvalidRefAddrBetween) {
   // Create a single compile unit with a single function that has a DW_AT_type
   // with a valid .debug_info offset, but the offset is between two DIEs.
   const char *yamldata = R"(
     debug_str:
       - ''
debug_info:
             Values:
               - Value:           0x000000000000000D
               - Value:           0x0000000000000011
           - AbbrCode:        0x00000000
             Values:
   )";
   auto ErrOrSections = DWARFYAML::EmitDebugSections(StringRef(yamldata));
   ASSERT_TRUE((bool)ErrOrSections);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(
+      DwarfContext,
+      "error: invalid DIE reference 0x00000011. Offset is in between DIEs:");
+}
 
-  auto &DebugSections = *ErrOrSections;
-
-  DWARFContextInMemory DwarfContext(DebugSections, 8);
+TEST(DWARFDebugInfo, TestDwarfVerifyInvalidLineSequence) {
+  // Create a single compile unit whose line table has a sequence in it where
+  // the address decreases.
+  StringRef yamldata = R"(
+    debug_str:
+      - ''
+      - /tmp/main.c
+    debug_abbrev:
+      - Code:            0x00000001
+        Tag:             DW_TAG_compile_unit
+        Children:        DW_CHILDREN_no
+        Attributes:
+          - Attribute:       DW_AT_name
+            Form:            DW_FORM_strp
+          - Attribute:       DW_AT_stmt_list
+            Form:            DW_FORM_sec_offset
+    debug_info:
+      - Length:
+          TotalLength:     16
+        Version:         4
+        AbbrOffset:      0
+        AddrSize:        8
+        Entries:
+          - AbbrCode:        0x00000001
+            Values:
+              - Value:           0x0000000000000001
+              - Value:           0x0000000000000000
+    debug_line:
+      - Length:
+          TotalLength:     68
+        Version:         2
+        PrologueLength:  34
+        MinInstLength:   1
+        DefaultIsStmt:   1
+        LineBase:        251
+        LineRange:       14
+        OpcodeBase:      13
+        StandardOpcodeLengths: [ 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1 ]
+        IncludeDirs:
+          - /tmp
+        Files:
+          - Name:            main.c
+            DirIdx:          1
+            ModTime:         0
+            Length:          0
+        Opcodes:
+          - Opcode:          DW_LNS_extended_op
+            ExtLen:          9
+            SubOpcode:       DW_LNE_set_address
+            Data:            4112
+          - Opcode:          DW_LNS_advance_line
+            SData:           9
+            Data:            4112
+          - Opcode:          DW_LNS_copy
+            Data:            4112
+          - Opcode:          DW_LNS_advance_pc
+            Data:            18446744073709551600
+          - Opcode:          DW_LNS_extended_op
+            ExtLen:          1
+            SubOpcode:       DW_LNE_end_sequence
+            Data:            18446744073709551600
+  )";
+  auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
+  ASSERT_TRUE((bool)ErrOrSections);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(DwarfContext, "error: .debug_line[0x00000000] row[1] decreases "
+                            "in address from previous row:");
+}
 
-  std::string str;
-  raw_string_ostream strm(str);
-  EXPECT_FALSE(DwarfContext.verify(strm, DIDT_All));
-  strm.flush();
-  const char *err = "error: invalid DIE reference 0x00000011. Offset is in "
-      "between DIEs:";
-  EXPECT_TRUE(strm.str().find(err) != std::string::npos);
+TEST(DWARFDebugInfo, TestDwarfVerifyInvalidLineFileIndex) {
+  // Create a single compile unit whose line table has a line table row with
+  // an invalid file index.
+  StringRef yamldata = R"(
+    debug_str:
+      - ''
+      - /tmp/main.c
+    debug_abbrev:
+      - Code:            0x00000001
+        Tag:             DW_TAG_compile_unit
+        Children:        DW_CHILDREN_no
+        Attributes:
+          - Attribute:       DW_AT_name
+            Form:            DW_FORM_strp
+          - Attribute:       DW_AT_stmt_list
+            Form:            DW_FORM_sec_offset
+    debug_info:
+      - Length:
+          TotalLength:     16
+        Version:         4
+        AbbrOffset:      0
+        AddrSize:        8
+        Entries:
+          - AbbrCode:        0x00000001
+            Values:
+              - Value:           0x0000000000000001
+              - Value:           0x0000000000000000
+    debug_line:
+      - Length:
+          TotalLength:     61
+        Version:         2
+        PrologueLength:  34
+        MinInstLength:   1
+        DefaultIsStmt:   1
+        LineBase:        251
+        LineRange:       14
+        OpcodeBase:      13
+        StandardOpcodeLengths: [ 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1 ]
+        IncludeDirs:
+          - /tmp
+        Files:
+          - Name:            main.c
+            DirIdx:          1
+            ModTime:         0
+            Length:          0
+        Opcodes:
+          - Opcode:          DW_LNS_extended_op
+            ExtLen:          9
+            SubOpcode:       DW_LNE_set_address
+            Data:            4096
+          - Opcode:          DW_LNS_advance_line
+            SData:           9
+            Data:            4096
+          - Opcode:          DW_LNS_copy
+            Data:            4096
+          - Opcode:          DW_LNS_advance_pc
+            Data:            16
+          - Opcode:          DW_LNS_set_file
+            Data:            5
+          - Opcode:          DW_LNS_extended_op
+            ExtLen:          1
+            SubOpcode:       DW_LNE_end_sequence
+            Data:            5
+  )";
+  auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
+  ASSERT_TRUE((bool)ErrOrSections);
+  DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
+  VerifyError(DwarfContext, "error: .debug_line[0x00000000][1] has invalid "
+                            "file index 5 (valid values are [1,1]):");
 }
-  
 } // end anonymous namespace