lldb-dwarfdump -verify [-quiet]

[clayborg]

Summary

Adds initial llvm-dwarfdump --verify support with unit tests.

lldb-dwarfdump gets a new "--verify" option that will verify a single file's DWARF debug info and will print out any errors that it finds. It will return an non-zero exit status if verification fails, and a zero exit status if verification succeeds. Adding the --quiet option will suppress any output the STDOUT or STDERR.

The first part of the verify does the following:

• verifies that all CU relative references (DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8, DW_FORM_ref_udata) have valid CU offsets
• verifies that all DW_FORM_ref_addr references have valid .debug_info offsets
• verifies that all DW_AT_ranges attributes have valid .debug_ranges offsets
• verifies that all DW_AT_stmt_list attributes have valid .debug_line offsets
• verifies that all DW_FORM_strp attributes have valid .debug_str offsets

Unit tests were added for each of the above cases.

[probinson]

Mostly formatting and commentary points. I haven't looked at the test yet.

lib/DebugInfo/DWARF/DWARFContext.cpp

289

I know this is the idiom used everywhere else, but here instead of the 'if' guarding a call or a just a few lines, it's guarding essentially the entire method. I'd rather see this inverted to an early exit here, and reduce indentation in the rest of the method.

301

So, most cross-section references are verified based on the attribute (because they use forms that can refer to different sections based on context), but sometimes they are just based on the form (because the form only allows a reference to one other section, like FORM_strp). Did I get that right? It would be nice to see a comment alluding to why some references are done one way and some another way.

302

This indentation doesn't look right; maybe use clang-format?

391

I wonder if forms that should have been handled by-attribute should be explicitly documented here. Or maybe that would be too much clutter? I am not sure.

[clayborg]

lib/DebugInfo/DWARF/DWARFContext.cpp

289

I am breaking my change up into many piece more to come. This if should remain for now since the a future patch will need this to be here.

301

I can add a comment.

391

We would mention them here, but I think that might clutter things.

[probinson]

LGTM but I think Adrian should have a chance at it, as he had many comments on the previous iteration.

lib/DebugInfo/DWARF/DWARFContext.cpp

289

ok but will probably want to be broken up into easier-to-digest pieces later then.

[aprantl]

lib/DebugInfo/DWARF/DWARFContext.cpp

288

Success

290

Would it make sense to split this entire verifier into a separate function?
Alternatively, if many verifiers need to iterate over the same data, would it make sense to split this out into a verify/visitCompileUnit function?

293

please clang-format

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

107

Do we really want to exit() here? What happens when llvm-dwarfdump is invoked on a .dSYM or static archive with more than one object file?

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

1711

Whoa. This looks nice! Out of curiosity, is there a specific advantage to doing this as a unit test as opposed to a FileCheck-based test?

[clayborg]

lib/DebugInfo/DWARF/DWARFContext.cpp

290

One issue with splitting it out is we will need to pass all data structures to those functions. For instance, the .debug_arange verifier will need access to a set of FunctionInfos (see previous patch). So I can split it out, but this function needs to be called even when .debug_info isn't being verified if we are verifying .debug_aranges because we will need to truth of what function ranges are in a CU and be able to compare it to the contents of the .debug_aranges. Let me know what you think...

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

107

I could make a static variable that gets set to true and exit after the iterations of all files and objects is done. It would be a bit messy to try and plumb the bool return value through since the dump and verify share the same code right now?

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

1711

Easier to debug and edit and fix is my best answer.

[clayborg]

• clang-format
• fixes for Adrian

[clayborg]

Marked things done

[clayborg]

Don't exit right away in llvm-dwarfdump if we encounter errors, exit with non-zero status after we have iterated across all files.

[aprantl]

lib/DebugInfo/DWARF/DWARFContext.cpp

290

Perhaps we can model it after llvm/lib/IR/Verifier.cpp.
It uses a private Verifier class that has visit[Enity] methods that implement various checks. State is passed through class members.

Would something like that work?

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

107

We should probably just make verify a separate action from dump.

117

... and rename this to ProcessInput or something

129

... {
  if (Dump && !Quiet)
     DumpObjectFile(*Obj, Filename);
  if (Verify)
     Result |= VerifyObjectFile(...)
}

etc.

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

1711

As long as we don't need any regex-matching on the output, this should be fine. And we can easily convert it to FileCheck later on.

[clayborg]

lib/DebugInfo/DWARF/DWARFContext.cpp

290

I can make it work. Can I do that in the next patch that will add the next level of functionality?

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

129

There are two calls to DumpObjectFile here, see the call below. Do we want to duplicate the twine below twice? Seems cleaner to do it the way it is currently done? The top loop uses std::for_each to we can't get the return value so we have to use a global anyway.

[aprantl]

LGTM once outstanding issues are addressed.

lib/DebugInfo/DWARF/DWARFContext.cpp

290

Sure! I think we agree on the direction the code should evolve to and that is what is important here.

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

129

If we stick with boolean return values, we could use std::all_of(Objects.begin(), Objects.end(), Verify) and it would still look kind of nice.

[aprantl]

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

129

Hmm.. I guess it will be more like:

auto Action = [&](Object *Obj)->bool {
 bool Result = true;
  if (Dump && !Quiet)
     DumpObjectFile(*Obj);
  if (Verify)
     Result = VerifyObjectFile(Obj);
  return Result; 
};

std::all_of(Objects.begin(), Objects.end(), Action)

[clayborg]

Fixed llvm-dwarfdump.cpp to use std::all_of.

include/llvm/DebugInfo/DIContext.h

public:
   DIContext(DIContextKind K) : Kind(K) {}
   virtual ~DIContext() = default;
 
   DIContextKind getKind() const { return Kind; }
 
   virtual void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
                     bool DumpEH = false, bool SummarizeTypes = false) = 0;
 
+  virtual bool verify(raw_ostream &OS, DIDumpType DumpType = DIDT_All) {
+    // No verifier? Just say things went well.
+    return true;
+  }
   virtual DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DILineInfoTable getLineInfoForAddressRange(uint64_t Address,
       uint64_t Size, DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DIInliningInfo getInliningInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
 
 private:

include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
 
   static bool classof(const DIContext *DICtx) {
     return DICtx->getKind() == CK_DWARF;
   }
 
   void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
             bool DumpEH = false, bool SummarizeTypes = false) override;
 
+  bool verify(raw_ostream &OS, DIDumpType DumpType = DIDT_All) override;
+
   typedef DWARFUnitSection<DWARFCompileUnit>::iterator_range cu_iterator_range;
   typedef DWARFUnitSection<DWARFTypeUnit>::iterator_range tu_iterator_range;
   typedef iterator_range<decltype(TUs)::iterator> tu_section_iterator_range;
 
   /// Get compile units in this context.
   cu_iterator_range compile_units() {
     parseCompileUnits();
     return cu_iterator_range(CUs.begin(), CUs.end());

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

private:
   dwarf::Form Form; // Form for this value.
   ValueType Value; // Contains all data for the form.
   const DWARFUnit *U = nullptr; // Remember the DWARFUnit at extract time.
 
 public:
   DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F) {}
 
   dwarf::Form getForm() const { return Form; }
+  uint64_t getRawUValue() const { return Value.uval; }
   void setForm(dwarf::Form F) { Form = F; }
   void setUValue(uint64_t V) { Value.uval = V; }
   void setSValue(int64_t V) { Value.sval = V; }
   void setPValue(const char *V) { Value.cstr = V; }
 
   void setBlockValue(const ArrayRef<uint8_t> &Data) {
     Value.data = Data.data();
     setUValue(Data.size());

lib/DebugInfo/DWARF/DWARFContext.cpp

if (DumpType == DIDT_All || DumpType == DIDT_AppleNamespaces)
     dumpAccelSection(OS, "apple_namespaces", getAppleNamespacesSection(),
                      getStringSection(), isLittleEndian());
 
   if (DumpType == DIDT_All || DumpType == DIDT_AppleObjC)
     dumpAccelSection(OS, "apple_objc", getAppleObjCSection(),
                      getStringSection(), isLittleEndian());
 }
 
+bool DWARFContext::verify(raw_ostream &OS, DIDumpType DumpType) {
+  bool success = true;
+  if (DumpType == DIDT_All || DumpType == DIDT_Info) {
+    OS << "Verifying .debug_info...\n";
+    for (const auto &CU : compile_units()) {
+      unsigned NumDies = CU->getNumDIEs();
+      for (unsigned I=0; I<NumDies; ++I) {
+        auto Die = CU->getDIEAtIndex(I);
+        const auto Tag = Die.getTag();
+        if (Tag == DW_TAG_null)
+          continue;
+        for (auto AttrValue : Die.attributes()) {
+          const auto Attr = AttrValue.Attr;
+          const auto Form = AttrValue.Value.getForm();
+          switch (Attr) {
+            case DW_AT_ranges:
+              // Make sure the offset in the DW_AT_ranges attribute is valid.
+              if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
+                if (*SectionOffset >= getRangeSection().Data.size()) {
+                  success = false;
+                  OS << "error: DW_AT_ranges offset is beyond .debug_ranges "
+                      "bounds:\n";
+                  Die.dump(OS, 0);
+                  OS << "\n";
+                }
+              } else {
+                success = false;
+                OS << "error: DIE has invalid DW_AT_ranges encoding:\n";
+                Die.dump(OS, 0);
+                OS << "\n";
+              }
+              break;
+            case DW_AT_stmt_list:
+              // Make sure the offset in the DW_AT_stmt_list attribute is valid.
+              if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
+                if (*SectionOffset >= getLineSection().Data.size()) {
+                  success = false;
+                  OS << "error: DW_AT_stmt_list offset is beyond .debug_line "
+                      "bounds: " << format("0x%08" PRIx32, *SectionOffset)
+                      << "\n";
+                  CU->getUnitDIE().dump(OS, 0);
+                  OS << "\n";
+                }
+              } else {
+                success = false;
+                OS << "error: DIE has invalid DW_AT_stmt_list encoding:\n";
+                Die.dump(OS, 0);
+                OS << "\n";
+              }
+              break;
+
+            default:
+              break;
+          }
+          switch (Form) {
+            case DW_FORM_ref1:
+            case DW_FORM_ref2:
+            case DW_FORM_ref4:
+            case DW_FORM_ref8:
+            case DW_FORM_ref_udata: {
+              // Verify all CU relative references are valid CU offsets.
+              Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
+              assert(RefVal);
+              if (RefVal) {
+                auto DieCU = Die.getDwarfUnit();
+                auto CUSize = DieCU->getNextUnitOffset() - DieCU->getOffset();
+                auto CUOffset = AttrValue.Value.getRawUValue();
+                if (CUOffset >= CUSize) {
+                  success = false;
+                  OS << "error: " << FormEncodingString(Form)
+                  << " CU offset " << format("0x%08" PRIx32, CUOffset)
+                  << " is invalid (must be less than CU size of "
+                  << format("0x%08" PRIx32, CUSize) << "):\n";
+                  Die.dump(OS, 0);
+                  OS << "\n";
+                }
+              }
+              break;
+            }
+            case DW_FORM_ref_addr: {
+              // Verify all absolute DIE references have valid offsets in the
+              // .debug_info section.
+              Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
+              assert(RefVal);
+              if (RefVal && *RefVal >= getInfoSection().Data.size()) {
+                success = false;
+                OS << "error: DW_FORM_ref_addr offset beyond .debug_info "
+                    "bounds:\n";
+                Die.dump(OS, 0);
+                OS << "\n";
+              }
+              break;
+            }
+            case DW_FORM_strp: {
+              auto SecOffset = AttrValue.Value.getAsSectionOffset();
+              assert(SecOffset); // DW_FORM_strp is a section offset.
+              if (SecOffset && *SecOffset >= getStringSection().size()) {
+                success = false;
+                OS << "error: DW_FORM_strp offset beyond .debug_str bounds:\n";
+                Die.dump(OS, 0);
+                OS << "\n";
+              }
+              break;
+            }
+            default:
+              break;
+          }
+        }
+      }
+    }
+  }
+  return success;
+}
 const DWARFUnitIndex &DWARFContext::getCUIndex() {
   if (CUIndex)
     return *CUIndex;
 
   DataExtractor CUIndexData(getCUIndexSection(), isLittleEndian(), 0);
 
   CUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_INFO);
   CUIndex->parse(CUIndexData);

lib/DebugInfo/DWARF/DWARFFormValue.cpp

case DW_FORM_GNU_strp_alt:
     return (FC == FC_String);
   case DW_FORM_implicit_const:
     return (FC == FC_Constant);
   default:
     break;
   }
   // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
   // Don't check for DWARF version here, as some producers may still do this
-  // by mistake.
-  return (Form == DW_FORM_data4 || Form == DW_FORM_data8) &&
-         FC == FC_SectionOffset;
+  // by mistake. Also accept DW_FORM_strp since this is .debug_str section
+  // offset.
+  return (Form == DW_FORM_data4 || Form == DW_FORM_data8 ||
+      Form == DW_FORM_strp) && FC == FC_SectionOffset;
 }
 
 bool DWARFFormValue::extractValue(const DataExtractor &data, 
                                   uint32_t *offset_ptr,
                                   const DWARFUnit *cu) {
   U = cu;
   bool indirect = false;
   bool is_block = false;

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

cl::values(
         clEnumValN(DIDT_CUIndex, "cu_index", ".debug_cu_index"),
         clEnumValN(DIDT_GdbIndex, "gdb_index", ".gdb_index"),
         clEnumValN(DIDT_TUIndex, "tu_index", ".debug_tu_index")));
 
 static cl::opt<bool>
     SummarizeTypes("summarize-types",
                    cl::desc("Abbreviate the description of type unit entries"));
 
+static cl::opt<bool>
+    Verify("verify", cl::desc("Verify the DWARF debug info"));
+
+static cl::opt<bool>
+    Quiet("quiet", cl::desc("Use with -verify to not emit to STDOUT."));
+
 static void error(StringRef Filename, std::error_code EC) {
   if (!EC)
     return;
   errs() << Filename << ": " << EC.message() << "\n";
   exit(1);
 }
 
 static void DumpObjectFile(ObjectFile &Obj, Twine Filename) {
   std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(Obj));
 
+  if (Verify) {
+    // Verify the DWARF and exit with non-zero exit status if verification
+    // fails.
+    raw_ostream &stream = Quiet ? nulls() : outs();
+    stream << "Verifying " << Filename.str() << ":\tfile format "
+        << Obj.getFileFormatName() << "\n";
+    if (DICtx->verify(stream, DumpType)) {
+      stream << "No errors.\n";
+    } else {
+      stream << "Errors detected.\n";
+      exit(1);
+    }
+  } else {
+    // Dump the complete DWARF structure.
     outs() << Filename.str() << ":\tfile format " << Obj.getFileFormatName()
-         << "\n\n";
-  // Dump the complete DWARF structure.
     DICtx->dump(outs(), DumpType, false, SummarizeTypes);
   }
+}
 
 static void DumpInput(StringRef Filename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   error(Filename, BuffOrErr.getError());
   std::unique_ptr<MemoryBuffer> Buff = std::move(BuffOrErr.get());
 
   Expected<std::unique_ptr<Binary>> BinOrErr =
       object::createBinary(Buff->getMemBufferRef());
   if (!BinOrErr)
     error(Filename, errorToErrorCode(BinOrErr.takeError()));
 
   if (auto *Obj = dyn_cast<ObjectFile>(BinOrErr->get()))
     DumpObjectFile(*Obj, Filename);
   else if (auto *Fat = dyn_cast<MachOUniversalBinary>(BinOrErr->get()))
     for (auto &ObjForArch : Fat->objects()) {
       auto MachOOrErr = ObjForArch.getAsObjectFile();
       error(Filename, errorToErrorCode(MachOOrErr.takeError()));
       DumpObjectFile(**MachOOrErr,
                      Filename + " (" + ObjForArch.getArchFlagName() + ")");
     }
 }

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

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);
 }
 
+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:
+      - ''
+      - /tmp/main.c
+      - main
+    debug_abbrev:
+      - Code:            0x00000001
+        Tag:             DW_TAG_compile_unit
+        Children:        DW_CHILDREN_yes
+        Attributes:
+          - Attribute:       DW_AT_name
+            Form:            DW_FORM_strp
+      - Code:            0x00000002
+        Tag:             DW_TAG_subprogram
+        Children:        DW_CHILDREN_no
+        Attributes:
+          - Attribute:       DW_AT_name
+            Form:            DW_FORM_strp
+          - Attribute:       DW_AT_type
+            Form:            DW_FORM_ref4
+    debug_info:
+      - Length:
+          TotalLength:     22
+        Version:         4
+        AbbrOffset:      0
+        AddrSize:        8
+        Entries:
+          - AbbrCode:        0x00000001
+            Values:
+              - Value:           0x0000000000000001
+          - AbbrCode:        0x00000002
+            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);
+
+}
+
+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:
+      - ''
+      - /tmp/main.c
+      - main
+    debug_abbrev:
+      - Code:            0x00000001
+        Tag:             DW_TAG_compile_unit
+        Children:        DW_CHILDREN_yes
+        Attributes:
+          - Attribute:       DW_AT_name
+            Form:            DW_FORM_strp
+      - Code:            0x00000002
+        Tag:             DW_TAG_subprogram
+        Children:        DW_CHILDREN_no
+        Attributes:
+          - Attribute:       DW_AT_name
+            Form:            DW_FORM_strp
+          - Attribute:       DW_AT_type
+            Form:            DW_FORM_ref_addr
+    debug_info:
+      - Length:
+          TotalLength:     22
+        Version:         4
+        AbbrOffset:      0
+        AddrSize:        8
+        Entries:
+          - AbbrCode:        0x00000001
+            Values:
+              - Value:           0x0000000000000001
+          - AbbrCode:        0x00000002
+            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);
+}
+
+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:
+      - ''
+      - /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_ranges
+            Form:            DW_FORM_sec_offset
+    debug_info:
+      - Length:
+          TotalLength:     16
+        Version:         4
+        AbbrOffset:      0
+        AddrSize:        8
+        Entries:
+          - 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);
+}
+  
+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:
+      - ''
+      - /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:           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);
+}
+
+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_abbrev:
+      - Code:            0x00000001
+        Tag:             DW_TAG_compile_unit
+        Children:        DW_CHILDREN_no
+        Attributes:
+          - Attribute:       DW_AT_name
+            Form:            DW_FORM_strp
+    debug_info:
+      - Length:
+          TotalLength:     12
+        Version:         4
+        AbbrOffset:      0
+        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);
+}
+
 } // end anonymous namespace