[ELF] - Add ability for DWARFContextInMemory to exit early when any error happen.

[grimar]

Summary

Change introduces error reporting policy for DWARFContextInMemory.
New callback provided by client is able to handle error on it's
side and return Halt or Continue.

That allows to either keep current behavior when parser prints all errors
but continues parsing object or implement something very different, like
stop parsing on a first error and report an error from client side.

[dblaikie]

I'd probably favor the API change of returning Expected<unique_ptr<DWARFContext>> - potentially with a backwards-compatible API that maintains the old API (& calls the new API, reports any Error and silently returns the DWARFContext). Though as you say, some callers want to continue on error - so this new API wouldn't express that.

Probably what might work better is if a callback for error handling was provided (a default one would be to maintain the existing behavior: print and continue. But other callers could say "print and stop". (eg: instead of "AllowsError", have llvm::function_ref<bool(Error E)> HandleError then do 'if (HandleError(std::move(E))) { return; }" or the like)

Why is the speed of lld important when the input is broken anyway? Printing all the errors may make it easier for a user to address them all without going through several slow link steps to get more errors (the same reason the compiler doesn't stop after the first error)? (eg: one corrupted compressed section, then one non-corrupt compressed section)

Also important to include test coverage - potentially in a unit test (though testing the IO would be tricky - but you could test if, given an input that had one broken, followed by a non-broken thing, then with the "stop on error" case returns no things and the "continue on error" returns the one non-broken thing.

[grimar]

In D34328#783474, @dblaikie wrote:

I'd probably favor the API change of returning Expected<unique_ptr<DWARFContext>> - potentially with a backwards-compatible API that maintains the old API (& calls the new API, reports any Error and silently returns the DWARFContext). Though as you say, some callers want to continue on error - so this new API wouldn't express that.

Yes and I not sure how much is good to provide 2 API that are doing the same. I think doing something universal is cleaner,
even if it will require more reasonable amount of changes around, probably.

Probably what might work better is if a callback for error handling was provided (a default one would be to maintain the existing behavior: print and continue. But other callers could say "print and stop". (eg: instead of "AllowsError", have llvm::function_ref<bool(Error E)> HandleError then do 'if (HandleError(std::move(E))) { return; }" or the like)

That sounds really good for me. That way if we still have HadError flag or alike, we can print all errors in a format that is specific for any tool on its side and then after object is parsed check the flag and report final error then, if it is required.

Or even better may be return not a bool, but enum, like PRINT_AND_STOP, JUST_PRINT, JUST_STOP, IGNORE_AND_CONTINUE.
Last one may be used to emit warnings untill we do not implement some relocations for example, like for .gdb_index case (while it seems it does not affect index),
and after that can switch to errors in one single change.

One more case where it is useful is when we have callback on LLD side that print errors, we can implement the same error reporting strategy we already use now: a limit of 20 errors, we can print them on our side and return IGNORE_AND_CONTINUE,
all time until reaching the limit - we just return JUST_STOP. Then check the HadError flag and stop link.

Why is the speed of lld important when the input is broken anyway? Printing all the errors may make it easier for a user to address them all without going through several slow link steps to get more errors (the same reason the compiler doesn't stop after the first error)? (eg: one corrupted compressed section, then one non-corrupt compressed section)

it makes sence to me. Main reason for this patch is to add way to fail link somehow still, if we can report more errors, we can do that.

Also important to include test coverage - potentially in a unit test (though testing the IO would be tricky - but you could test if, given an input that had one broken, followed by a non-broken thing, then with the "stop on error" case returns no things and the "continue on error" returns the one non-broken thing.

OK.

Thanks a lot for your ideas, I will think a bit more on above and update patch with something different.

[grimar]

• Addressed review comments.
• Added testcase.

[grimar]

• Fix comment formatting.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFContext.h

357

Might be worth introducing an enum ("Halt/Continue") rather than using a bool, so it's more obvious/legible which result means what.

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

2150–2155

I thought one of the ideas of the yaml2obj stuff was to enable the writing of invalid inputs, etc - is that not the case? Should that functionality be added to the yaml2obj somehow rather than having big byte arrays?

[grimar]

• Addressed review comments.

include/llvm/DebugInfo/DWARF/DWARFContext.h

357

Done.

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

2150–2155

What I was trying to achieve here is to produce broken object::ObjectFile somehow to be able to test first constructor of DWARFContextInMemory with new functionality.
Extending yaml2obj to produce StringRef (if I correctly understood the suggestion) would require doing some librarification for it. Like splitting part of yaml2obj into separate library probably. And then test would be able to use such library.

It probably can be usefull (I am not sure how much other users we may have, looks can be usefull for testcases like this), but sounds as a large enough separate change. It is unclear for me if introducing a new library worth that atm.

Fortunately I found alternative way to achieve what I wanted initially in this testcase, without using additional arrays and dependency on yaml2obj. Solution partially consistent with other testcases in this file which aslo use dwarfgen::Generator but for different things.

Alternative solution I was thinking about - is to introduce --error-limit=X option to llvm-dwarfdump. It probably may be usefull itself and would allow to write testcase in a regular manner (separate test file + one/two broken input files and regular tools calls).

[dblaikie]

Looks great - thanks!

[grimar]

In D34328#792140, @dblaikie wrote:

Looks great - thanks!

Thanks for review ! I'll commit this at my tomorrow morning.
(want to be online for case if this breaks any slow BB or something else).

[chapuni]

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

18 ↗

(On Diff #104353)

s/Codegen/CodeGen/

[grimar]

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

18 ↗

(On Diff #104353)

Ah, thanks !

include/llvm/DebugInfo/DWARF/DWARFContext.h

class DWARFContextInMemory : public DWARFContext {
 
   StringRef *MapSectionToMember(StringRef Name);
 
   /// If Sec is compressed section, decompresses and updates its contents
   /// provided by Data. Otherwise leaves it unchanged.
   Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
                         StringRef &Data);
 
+  /// Function used to handle default error reporting policy. Prints a error
+  /// message and returns true, what says context to continue object
+  /// parsing and ignore the error.
+  static bool defaultErrorHandler(Error E);
+
 public:
-  DWARFContextInMemory(const object::ObjectFile &Obj,
-    const LoadedObjectInfo *L = nullptr);
+  DWARFContextInMemory(
+      const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
+      function_ref<bool(Error)> HandleError = defaultErrorHandler);
 
   DWARFContextInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
                        uint8_t AddrSize,
                        bool isLittleEndian = sys::IsLittleEndianHost);
 
   StringRef getFileName() const override { return FileName; }
   bool isLittleEndian() const override { return IsLittleEndian; }
   uint8_t getAddressSize() const override { return AddressSize; }

lib/DebugInfo/DWARF/DWARFContext.cpp

static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
   if (Sym != Obj.symbol_end()) {
     bool New;
     std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
     if (!New)
       return CacheIt->second;
 
     Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
     if (!SymAddrOrErr)
-      return createError("error: failed to compute symbol address: ",
+      return createError("failed to compute symbol address: ",
                          SymAddrOrErr.takeError());
 
     // Also remember what section this symbol is in for later
     auto SectOrErr = Sym->getSection();
     if (!SectOrErr)
-      return createError("error: failed to get symbol section: ",
+      return createError("failed to get symbol section: ",
                          SectOrErr.takeError());
 
     RSec = *SectOrErr;
     Ret.Address = *SymAddrOrErr;
   } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
     RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
     Ret.Address = RSec->getAddress();
   }
if (auto Err = Decompressor->resizeAndDecompress(Out))
     return Err;
 
   UncompressedSections.emplace_back(std::move(Out));
   Data = UncompressedSections.back();
 
   return Error::success();
 }
 
-DWARFContextInMemory::DWARFContextInMemory(const object::ObjectFile &Obj,
-                                           const LoadedObjectInfo *L)
+bool DWARFContextInMemory::defaultErrorHandler(Error E) {
+  errs() << "error: " + toString(std::move(E)) << '\n';
+  return true;
+}
+
+DWARFContextInMemory::DWARFContextInMemory(
+    const object::ObjectFile &Obj, const LoadedObjectInfo *L,
+    function_ref<bool(Error)> HandleError)
     : FileName(Obj.getFileName()), IsLittleEndian(Obj.isLittleEndian()),
       AddressSize(Obj.getBytesInAddress()) {
   for (const SectionRef &Section : Obj.sections()) {
     StringRef name;
     Section.getName(name);
     // Skip BSS and Virtual sections, they aren't interesting.
     bool IsBSS = Section.isBSS();
     if (IsBSS)
       continue;
     bool IsVirtual = Section.isVirtual();
     if (IsVirtual)
       continue;
     StringRef data;
 
     section_iterator RelocatedSection = Section.getRelocatedSection();
     // Try to obtain an already relocated version of this section.
     // Else use the unrelocated section from the object file. We'll have to
     // apply relocations ourselves later.
     if (!L || !L->getLoadedSectionContents(*RelocatedSection, data))
       Section.getContents(data);
 
     if (auto Err = maybeDecompress(Section, name, data)) {
-      errs() << "error: failed to decompress '" + name + "', " +
-                    toString(std::move(Err))
-             << '\n';
+      if (!HandleError(createError("failed to decompress '" + name + "', ",
+                                   std::move(Err))))
+        return;
       continue;
     }
 
     // Compressed sections names in GNU style starts from ".z",
     // at this point section is decompressed and we drop compression prefix.
     name = name.substr(
         name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
 
for (const SectionRef &Section : Obj.sections()) {
     for (const RelocationRef &Reloc : Section.relocations()) {
       // FIXME: it's not clear how to correctly handle scattered
       // relocations.
       if (isRelocScattered(Obj, Reloc))
         continue;
 
       Expected<SymInfo> SymInfoOrErr = getSymbolInfo(Obj, Reloc, L, AddrCache);
       if (!SymInfoOrErr) {
-        errs() << toString(SymInfoOrErr.takeError()) << '\n';
+        if (!HandleError(SymInfoOrErr.takeError()))
+          return;
         continue;
       }
 
       object::RelocVisitor V(Obj);
       uint64_t Val = V.visit(Reloc.getType(), Reloc, SymInfoOrErr->Address);
       if (V.error()) {
         SmallString<32> Name;
         Reloc.getTypeName(Name);
-        errs() << "error: failed to compute relocation: " << Name << "\n";
+        if (!HandleError(
+                createError("failed to compute relocation: " + name + ", ",
+                            errorCodeToError(object_error::parse_failed))))
+          return;
         continue;
       }
       RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val};
       Map->insert({Reloc.getOffset(), Rel});
     }
   }
 }
 

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

template <uint16_t Version, class AddrType> void TestAddresses() {
   initLLVMIfNeeded();
   Triple Triple = getHostTripleForAddrSize(AddrSize);
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   if (HandleExpectedError(ExpectedDG))
     return;
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
   dwarfgen::DIE CUDie = CU.getUnitDIE();
-  
   CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
   CUDie.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
-  
   // Create a subprogram DIE with no low or high PC.
   dwarfgen::DIE SubprogramNoPC = CUDie.addChild(DW_TAG_subprogram);
   SubprogramNoPC.addAttribute(DW_AT_name, DW_FORM_strp, "no_pc");
 
   // Create a subprogram DIE with a low PC only.
   dwarfgen::DIE SubprogramLowPC = CUDie.addChild(DW_TAG_subprogram);
   SubprogramLowPC.addAttribute(DW_AT_name, DW_FORM_strp, "low_pc");
   const uint64_t ActualLowPC = 0x1000;
   const uint64_t ActualHighPC = 0x2000;
   const uint64_t ActualHighPCOffset = ActualHighPC - ActualLowPC;
   SubprogramLowPC.addAttribute(DW_AT_low_pc, DW_FORM_addr, ActualLowPC);
 
   // Create a subprogram DIE with a low and high PC.
   dwarfgen::DIE SubprogramLowHighPC = CUDie.addChild(DW_TAG_subprogram);
   SubprogramLowHighPC.addAttribute(DW_AT_name, DW_FORM_strp, "low_high_pc");
   SubprogramLowHighPC.addAttribute(DW_AT_low_pc, DW_FORM_addr, ActualLowPC);
   // Encode the high PC as an offset from the low PC if supported.
   if (SupportsHighPCAsOffset)
     SubprogramLowHighPC.addAttribute(DW_AT_high_pc, DW_FORM_data4,
                                      ActualHighPCOffset);
   else
     SubprogramLowHighPC.addAttribute(DW_AT_high_pc, DW_FORM_addr, ActualHighPC);
-  
   StringRef FileBytes = DG->generate();
   MemoryBufferRef FileBuffer(FileBytes, "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   EXPECT_TRUE((bool)Obj);
   DWARFContextInMemory DwarfContext(*Obj.get());
-  
   // 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 DieDG = U->getUnitDIE(false);
   EXPECT_TRUE(DieDG.isValid());
 
   uint64_t LowPC, HighPC, SectionIndex;
   Optional<uint64_t> OptU64;
   // Verify the that our subprogram with no PC value fails appropriately when
   // asked for any PC values.
   auto SubprogramDieNoPC = DieDG.getFirstChild();
   EXPECT_TRUE(SubprogramDieNoPC.isValid());
   EXPECT_EQ(SubprogramDieNoPC.getTag(), DW_TAG_subprogram);
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_low_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toUnsigned(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = SubprogramDieNoPC.getHighPC(ActualLowPC);
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
- 
   // Verify the that our subprogram with only a low PC value succeeds when
   // we ask for the Low PC, but fails appropriately when asked for the high PC
   // or both low and high PC values.
   auto SubprogramDieLowPC = SubprogramDieNoPC.getSibling();
   EXPECT_TRUE(SubprogramDieLowPC.isValid());
   EXPECT_EQ(SubprogramDieLowPC.getTag(), DW_TAG_subprogram);
   OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_low_pc));
   EXPECT_TRUE((bool)OptU64);
TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Addresses) {
   typedef uint64_t AddrType;
   TestAddresses<4, AddrType>();
 }
 
 TEST(DWARFDebugInfo, TestRelations) {
   // Test the DWARF APIs related to accessing the DW_AT_low_pc and
   // DW_AT_high_pc.
   uint16_t Version = 4;
-  
   const uint8_t AddrSize = sizeof(void *);
   initLLVMIfNeeded();
   Triple Triple = getHostTripleForAddrSize(AddrSize);
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   if (HandleExpectedError(ExpectedDG))
     return;
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
-  
   enum class Tag: uint16_t  {
     A = dwarf::DW_TAG_lo_user,
     B,
     C,
     C1,
     C2,
     D,
     D1
// Scope to allow us to re-use the same DIE names
     C.addChild((dwarf::Tag)Tag::C2);
     D.addChild((dwarf::Tag)Tag::D1);
   }
 
   MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   EXPECT_TRUE((bool)Obj);
   DWARFContextInMemory DwarfContext(*Obj.get());
-  
   // 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);
   EXPECT_TRUE(CUDie.isValid());
-  
   // The compile unit doesn't have a parent or a sibling.
   auto ParentDie = CUDie.getParent();
   EXPECT_FALSE(ParentDie.isValid());
   auto SiblingDie = CUDie.getSibling();
   EXPECT_FALSE(SiblingDie.isValid());
-  
   // Get the children of the compile unit
   auto A = CUDie.getFirstChild();
   auto B = A.getFirstChild();
   auto C = B.getSibling();
   auto D = C.getSibling();
   auto Null = D.getSibling();
-  
   // Verify NULL Die is NULL and has no children or siblings
   EXPECT_TRUE(Null.isNULL());
   EXPECT_FALSE(Null.getSibling().isValid());
   EXPECT_FALSE(Null.getFirstChild().isValid());
-  
   // Verify all children of the compile unit DIE are correct.
   EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A);
   EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B);
   EXPECT_EQ(C.getTag(), (dwarf::Tag)Tag::C);
   EXPECT_EQ(D.getTag(), (dwarf::Tag)Tag::D);
 
   // Verify who has children
   EXPECT_TRUE(A.hasChildren());
   EXPECT_FALSE(B.hasChildren());
   EXPECT_TRUE(C.hasChildren());
   EXPECT_TRUE(D.hasChildren());
 
   // Make sure the parent of all the children of the compile unit are the
   // compile unit.
   EXPECT_EQ(A.getParent(), CUDie);
-  
   // Make sure the parent of all the children of A are the A.
   // B is the first child in A, so we need to verify we can get the previous
   // DIE as the parent.
   EXPECT_EQ(B.getParent(), A);
   // C is the second child in A, so we need to make sure we can backup across
   // other DIE (B) at the same level to get the correct parent.
   EXPECT_EQ(C.getParent(), A);
   // D is the third child of A. We need to verify we can backup across other DIE
   // (B and C) including DIE that have children (D) to get the correct parent.
   EXPECT_EQ(D.getParent(), A);
 
   // Verify that a DIE with no children returns an invalid DWARFDie.
   EXPECT_FALSE(B.getFirstChild().isValid());
 
   // Verify the children of the B DIE
   auto C1 = C.getFirstChild();
   auto C2 = C1.getSibling();
   EXPECT_TRUE(C2.getSibling().isNULL());
-  
   // Verify all children of the B DIE correctly valid or invalid.
   EXPECT_EQ(C1.getTag(), (dwarf::Tag)Tag::C1);
   EXPECT_EQ(C2.getTag(), (dwarf::Tag)Tag::C2);
 
   // Make sure the parent of all the children of the B are the B.
   EXPECT_EQ(C1.getParent(), C);
   EXPECT_EQ(C2.getParent(), C);
 }
 
 TEST(DWARFDebugInfo, TestDWARFDie) {
   // Make sure a default constructed DWARFDie doesn't have any parent, sibling
   // or child;
   DWARFDie DefaultDie;
   EXPECT_FALSE(DefaultDie.getParent().isValid());
   EXPECT_FALSE(DefaultDie.getFirstChild().isValid());
   EXPECT_FALSE(DefaultDie.getSibling().isValid());
 }
 
 TEST(DWARFDebugInfo, TestChildIterators) {
   // Test the DWARF APIs related to iterating across the children of a DIE using
   // the DWARFDie::iterator class.
   uint16_t Version = 4;
-  
   const uint8_t AddrSize = sizeof(void *);
   initLLVMIfNeeded();
   Triple Triple = getHostTripleForAddrSize(AddrSize);
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   if (HandleExpectedError(ExpectedDG))
     return;
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
-  
   enum class Tag: uint16_t  {
     A = dwarf::DW_TAG_lo_user,
     B,
   };
-  
   // Scope to allow us to re-use the same DIE names
   {
     // Create DWARF tree that looks like:
     //
     // CU
     //   A
     //   B
     auto CUDie = CU.getUnitDIE();
     CUDie.addChild((dwarf::Tag)Tag::A);
     CUDie.addChild((dwarf::Tag)Tag::B);
   }
-  
   MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   EXPECT_TRUE((bool)Obj);
   DWARFContextInMemory DwarfContext(*Obj.get());
-  
   // 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);
   EXPECT_TRUE(CUDie.isValid());
   uint32_t Index;
   DWARFDie A;
   DWARFDie B;
-  
   // Verify the compile unit DIE's children.
   Index = 0;
   for (auto Die : CUDie.children()) {
     switch (Index++) {
       case 0: A = Die; break;
       case 1: B = Die; break;
     }
   }
-  
   EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A);
   EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B);
 
   // Verify that A has no children by verifying that the begin and end contain
   // invalid DIEs and also that the iterators are equal.
   EXPECT_EQ(A.begin(), A.end());
 }
 
TEST(DWARFDebugInfo, TestEmptyChildren) {
   // 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);
   EXPECT_TRUE(CUDie.isValid());
-  
   // Verify that the CU Die that says it has children, but doesn't, actually
   // has begin and end iterators that are equal. We want to make sure we don't
   // see the Null DIEs during iteration.
   EXPECT_EQ(CUDie.begin(), CUDie.end());
 }
 
 TEST(DWARFDebugInfo, TestAttributeIterators) {
   // Test the DWARF APIs related to iterating across all attribute values in a
   // a DWARFDie.
   uint16_t Version = 4;
-  
   const uint8_t AddrSize = sizeof(void *);
   initLLVMIfNeeded();
   Triple Triple = getHostTripleForAddrSize(AddrSize);
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   if (HandleExpectedError(ExpectedDG))
     return;
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
   const uint64_t CULowPC = 0x1000;
   StringRef CUPath("/tmp/main.c");
-  
   // Scope to allow us to re-use the same DIE names
   {
     auto CUDie = CU.getUnitDIE();
     // Encode an attribute value before an attribute with no data.
     CUDie.addAttribute(DW_AT_name, DW_FORM_strp, CUPath.data());
     // Encode an attribute value with no data in .debug_info/types to ensure
     // the iteration works correctly.
     CUDie.addAttribute(DW_AT_declaration, DW_FORM_flag_present);
     // Encode an attribute value after an attribute with no data.
     CUDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, CULowPC);
   }
-  
   MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   EXPECT_TRUE((bool)Obj);
   DWARFContextInMemory DwarfContext(*Obj.get());
-  
   // 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);
   EXPECT_TRUE(CUDie.isValid());
-  
   auto R = CUDie.attributes();
   auto I = R.begin();
   auto E = R.end();
-  
   ASSERT_NE(E, I);
   EXPECT_EQ(I->Attr, DW_AT_name);
   auto ActualCUPath = I->Value.getAsCString();
   EXPECT_EQ(CUPath, *ActualCUPath);
-  
   ASSERT_NE(E, ++I);
   EXPECT_EQ(I->Attr, DW_AT_declaration);
   EXPECT_EQ(1ull, *I->Value.getAsUnsignedConstant());
-  
   ASSERT_NE(E, ++I);
   EXPECT_EQ(I->Attr, DW_AT_low_pc);
   EXPECT_EQ(CULowPC, *I->Value.getAsAddress());
-  
   EXPECT_EQ(E, ++I);
 }
 
 TEST(DWARFDebugInfo, TestFindRecurse) {
   uint16_t Version = 4;
-  
   const uint8_t AddrSize = sizeof(void *);
   initLLVMIfNeeded();
   Triple Triple = getHostTripleForAddrSize(AddrSize);
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   if (HandleExpectedError(ExpectedDG))
     return;
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
-  
   StringRef SpecDieName = "spec";
   StringRef SpecLinkageName = "spec_linkage";
   StringRef AbsDieName = "abs";
   // Scope to allow us to re-use the same DIE names
   {
     auto CUDie = CU.getUnitDIE();
     auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram);
     auto FuncAbsDie = CUDie.addChild(DW_TAG_subprogram);
     auto FuncDie = CUDie.addChild(DW_TAG_subprogram);
     auto VarAbsDie = CUDie.addChild(DW_TAG_variable);
     auto VarDie = CUDie.addChild(DW_TAG_variable);
     FuncSpecDie.addAttribute(DW_AT_name, DW_FORM_strp, SpecDieName);
     FuncAbsDie.addAttribute(DW_AT_linkage_name, DW_FORM_strp, SpecLinkageName);
     FuncAbsDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie);
     FuncDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, FuncAbsDie);
     VarAbsDie.addAttribute(DW_AT_name, DW_FORM_strp, AbsDieName);
     VarDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, VarAbsDie);
   }
-  
   MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   EXPECT_TRUE((bool)Obj);
   DWARFContextInMemory DwarfContext(*Obj.get());
-  
   // 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);
   EXPECT_TRUE(CUDie.isValid());
-  
   auto FuncSpecDie = CUDie.getFirstChild();
   auto FuncAbsDie = FuncSpecDie.getSibling();
   auto FuncDie = FuncAbsDie.getSibling();
   auto VarAbsDie = FuncDie.getSibling();
   auto VarDie = VarAbsDie.getSibling();
 
   // Make sure we can't extract the name from the specification die when using
   // DWARFDie::find() since it won't check the DW_AT_specification DIE.
   EXPECT_FALSE(FuncDie.find(DW_AT_name));
 
   // Make sure we can extract the name from the specification die when using
   // DWARFDie::findRecursively() since it should recurse through the
   // DW_AT_specification DIE.
   auto NameOpt = FuncDie.findRecursively(DW_AT_name);
   EXPECT_TRUE(NameOpt);
   // Test the dwarf::toString() helper function.
   auto StringOpt = toString(NameOpt);
   EXPECT_TRUE(StringOpt);
   EXPECT_EQ(SpecDieName, StringOpt.getValueOr(nullptr));
   // Test the dwarf::toString() helper function with a default value specified.
   EXPECT_EQ(SpecDieName, toString(NameOpt, nullptr));
 
   auto LinkageNameOpt = FuncDie.findRecursively(DW_AT_linkage_name);
   EXPECT_EQ(SpecLinkageName, toString(LinkageNameOpt).getValueOr(nullptr));
-  
   // Make sure we can't extract the name from the abstract origin die when using
   // DWARFDie::find() since it won't check the DW_AT_abstract_origin DIE.
   EXPECT_FALSE(VarDie.find(DW_AT_name));
-  
   // Make sure we can extract the name from the abstract origin die when using
   // DWARFDie::findRecursively() since it should recurse through the
   // DW_AT_abstract_origin DIE.
   NameOpt = VarDie.findRecursively(DW_AT_name);
   EXPECT_TRUE(NameOpt);
   // Test the dwarf::toString() helper function.
   StringOpt = toString(NameOpt);
   EXPECT_TRUE(StringOpt);
TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidS64, toSigned(FormValOpt, InvalidU64));
 
   // Test successful and unsuccessful unsigned constant decoding.
   uint64_t UData8 = 0x1020304050607080ULL;
   FormVal.setForm(DW_FORM_udata);
   FormVal.setUValue(UData8);
   FormValOpt = FormVal;
-  
   EXPECT_FALSE(toString(FormValOpt).hasValue());
   EXPECT_TRUE(toUnsigned(FormValOpt).hasValue());
   EXPECT_FALSE(toReference(FormValOpt).hasValue());
   EXPECT_TRUE(toSigned(FormValOpt).hasValue());
   EXPECT_FALSE(toAddress(FormValOpt).hasValue());
   EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
   EXPECT_FALSE(toBlock(FormValOpt).hasValue());
   EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
   EXPECT_EQ(UData8, toUnsigned(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
   EXPECT_EQ((int64_t)UData8, toSigned(FormValOpt, InvalidU64));
 
   // Test successful and unsuccessful reference decoding.
   uint32_t RefData = 0x11223344U;
   FormVal.setForm(DW_FORM_ref_addr);
   FormVal.setUValue(RefData);
   FormValOpt = FormVal;
-  
   EXPECT_FALSE(toString(FormValOpt).hasValue());
   EXPECT_FALSE(toUnsigned(FormValOpt).hasValue());
   EXPECT_TRUE(toReference(FormValOpt).hasValue());
   EXPECT_FALSE(toSigned(FormValOpt).hasValue());
   EXPECT_FALSE(toAddress(FormValOpt).hasValue());
   EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
   EXPECT_FALSE(toBlock(FormValOpt).hasValue());
   EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
   EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt, InvalidU64));
   EXPECT_EQ(RefData, toReference(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidS64, toSigned(FormValOpt, InvalidU64));
 
   // Test successful and unsuccessful signed constant decoding.
   int64_t SData8 = 0x1020304050607080ULL;
   FormVal.setForm(DW_FORM_udata);
   FormVal.setSValue(SData8);
   FormValOpt = FormVal;
-  
   EXPECT_FALSE(toString(FormValOpt).hasValue());
   EXPECT_TRUE(toUnsigned(FormValOpt).hasValue());
   EXPECT_FALSE(toReference(FormValOpt).hasValue());
   EXPECT_TRUE(toSigned(FormValOpt).hasValue());
   EXPECT_FALSE(toAddress(FormValOpt).hasValue());
   EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
   EXPECT_FALSE(toBlock(FormValOpt).hasValue());
   EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
   EXPECT_EQ((uint64_t)SData8, toUnsigned(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
   EXPECT_EQ(SData8, toSigned(FormValOpt, InvalidU64));
 
   // Test successful and unsuccessful block decoding.
   uint8_t Data[] = { 2, 3, 4 };
   ArrayRef<uint8_t> Array(Data);
   FormVal.setForm(DW_FORM_block1);
   FormVal.setBlockValue(Array);
   FormValOpt = FormVal;
-  
   EXPECT_FALSE(toString(FormValOpt).hasValue());
   EXPECT_FALSE(toUnsigned(FormValOpt).hasValue());
   EXPECT_FALSE(toReference(FormValOpt).hasValue());
   EXPECT_FALSE(toSigned(FormValOpt).hasValue());
   EXPECT_FALSE(toAddress(FormValOpt).hasValue());
   EXPECT_FALSE(toSectionOffset(FormValOpt).hasValue());
   auto BlockOpt = toBlock(FormValOpt);
   EXPECT_TRUE(BlockOpt.hasValue());
   EXPECT_EQ(*BlockOpt, Array);
   EXPECT_EQ(nullptr, toString(FormValOpt, nullptr));
   EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toReference(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toAddress(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt, InvalidU64));
   EXPECT_EQ(InvalidS64, toSigned(FormValOpt, InvalidU64));
 
   // Test
 }
 
 TEST(DWARFDebugInfo, TestFindAttrs) {
   // Test the DWARFDie::find() and DWARFDie::findRecursively() that take an
   // ArrayRef<dwarf::Attribute> value to make sure they work correctly.
   uint16_t Version = 4;
-  
   const uint8_t AddrSize = sizeof(void *);
   initLLVMIfNeeded();
   Triple Triple = getHostTripleForAddrSize(AddrSize);
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   if (HandleExpectedError(ExpectedDG))
     return;
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
-  
   StringRef DieMangled("_Z3fooi");
   // Scope to allow us to re-use the same DIE names
   {
     auto CUDie = CU.getUnitDIE();
     auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram);
     auto FuncDie = CUDie.addChild(DW_TAG_subprogram);
     FuncSpecDie.addAttribute(DW_AT_MIPS_linkage_name, DW_FORM_strp, DieMangled);
     FuncDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie);
   }
-  
   MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   EXPECT_TRUE((bool)Obj);
   DWARFContextInMemory DwarfContext(*Obj.get());
-  
   // 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);
   EXPECT_TRUE(CUDie.isValid());
-  
   auto FuncSpecDie = CUDie.getFirstChild();
   auto FuncDie = FuncSpecDie.getSibling();
 
   // Make sure that passing in an empty attribute list behave correctly.
   EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).hasValue());
 
   // Make sure that passing in a list of attribute that are not contained
   // in the DIE returns nothing.
   EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).hasValue());
 
   const dwarf::Attribute Attrs[] = {DW_AT_linkage_name,
                                     DW_AT_MIPS_linkage_name};
 
   // Make sure we can't extract the linkage name attributes when using
   // DWARFDie::find() since it won't check the DW_AT_specification DIE.
   EXPECT_FALSE(FuncDie.find(Attrs).hasValue());
-  
   // Make sure we can extract the name from the specification die when using
   // DWARFDie::findRecursively() since it should recurse through the
   // DW_AT_specification DIE.
   auto NameOpt = FuncDie.findRecursively(Attrs);
   EXPECT_TRUE(NameOpt.hasValue());
   EXPECT_EQ(DieMangled, toString(NameOpt, ""));
 }
 

 TEST(DWARFDebugInfo, TestDwarfVerifyCUDontShareLineTable) {
   // Create a two compile units where both compile units share the same
   // DW_AT_stmt_list value and verify we report the error correctly.
   StringRef yamldata = R"(
     debug_str:
       - ''
       - /tmp/main.c
       - /tmp/foo.c
-    debug_abbrev:    
+    debug_abbrev:
       - Code:            0x00000001
         Tag:             DW_TAG_compile_unit
         Children:        DW_CHILDREN_no
-        Attributes:      
+        Attributes:
           - Attribute:       DW_AT_name
             Form:            DW_FORM_strp
           - Attribute:       DW_AT_stmt_list
             Form:            DW_FORM_sec_offset
-    debug_info:      
-      - Length:          
+    debug_info:
+      - Length:
           TotalLength:     16
         Version:         4
         AbbrOffset:      0
         AddrSize:        8
-        Entries:         
+        Entries:
           - AbbrCode:        0x00000001
-            Values:          
+            Values:
               - Value:           0x0000000000000001
               - Value:           0x0000000000000000
-      - Length:          
+      - Length:
           TotalLength:     16
         Version:         4
         AbbrOffset:      0
         AddrSize:        8
-        Entries:         
+        Entries:
           - AbbrCode:        0x00000001
-            Values:          
+            Values:
               - Value:           0x000000000000000D
               - Value:           0x0000000000000000
-    debug_line:      
-      - Length:          
+    debug_line:
+      - Length:
           TotalLength:     60
         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:     
+        IncludeDirs:
           - /tmp
-        Files:           
+        Files:
           - Name:            main.c
             DirIdx:          1
             ModTime:         0
             Length:          0
-        Opcodes:         
+        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:            256
           - Opcode:          DW_LNS_extended_op
             ExtLen:          1
             SubOpcode:       DW_LNE_end_sequence
             Data:            256
   )";
   auto ErrOrSections = DWARFYAML::EmitDebugSections(yamldata);
   ASSERT_TRUE((bool)ErrOrSections);
   DWARFContextInMemory DwarfContext(*ErrOrSections, 8);
   VerifyError(DwarfContext, "error: two compile unit DIEs, 0x0000000b and "
                             "0x0000001f, have the same DW_AT_stmt_list section "
                             "offset:");
 }
 
+TEST(DWARFDebugInfo, TestErrorReportingPolicy) {
+  // Data contains bytes of object file generated by yaml2obj tool.
+  // YAML contains description of object with two broken compressed
+  // sections.
+  // To produce Data array next commands and following yaml file was used:
+  // yaml2obj test.s -o test.o
+  // xxd -i test.o
+  //
+  // !ELF
+  // FileHeader:
+  // Class: ELFCLASS64
+  //     Data: ELFDATA2LSB
+  //     Type: ET_REL
+  //     Machine: EM_X86_64
+  //     Sections:
+  //       -Name: .zdebug_foo
+  //         Type: SHT_PROGBITS
+  //         Content: "00000000"
+  //       -Name: .zdebug_bar
+  //         Type: SHT_PROGBITS
+  //         Content: "00000000"
+  //
+  const unsigned char Data[] = {
+      0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
+      0x06, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+      0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0xc4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0xc8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+      0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+      0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x19, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0xe1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x2e, 0x7a, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x62, 0x61,
+      0x72, 0x00, 0x2e, 0x7a, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x66, 0x6f,
+      0x6f, 0x00, 0x2e, 0x73, 0x68, 0x73, 0x74, 0x72, 0x74, 0x61, 0x62, 0x00,
+      0x2e, 0x73, 0x74, 0x72, 0x74, 0x61, 0x62, 0x00, 0x2e, 0x73, 0x79, 0x6d,
+      0x74, 0x61, 0x62, 0x00};
+  const size_t Size = sizeof(Data) / sizeof(Data[0]);
+
+  MemoryBufferRef FileBuffer(StringRef((char *)Data, Size), "dwarf");
+  auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
+  EXPECT_TRUE((bool)Obj);
+
+  // Case 1: error handler handles all errors. That allows DWARFContextInMemory
+  //         to parse whole file and find both two errors we know about.
+  int Errors = 0;
+  DWARFContextInMemory Ctx1(*Obj.get(), nullptr, [&](Error E) {
+    ++Errors;
+    consumeError(std::move(E));
+    return true;
+  });
+  EXPECT_TRUE(Errors == 2);
+
+  // Case 2: error handler stops parsing of object after first error.
+  Errors = 0;
+  DWARFContextInMemory Ctx2(*Obj.get(), nullptr, [&](Error E) {
+    ++Errors;
+    consumeError(std::move(E));
+    return false;
+  });
+  EXPECT_TRUE(Errors == 1);
+}
+
 } // end anonymous namespace