[ObjectYAML] Add support for error handling in DWARFYAML. NFC.

[Higuoxing]

Summary

This patch intends to be an NFC-patch. Test cases will be added in a follow-up patch.

[jhenderson]

To silence all the clang-tidy warnings, I'd be happy if you want to do a bulk renaming of the functions (to emitDebug*) as a separate commit before this patch. Since you're going to modify all those lines in this patch anyway, it'll not make git blame any worse, which is usually the motivation behind not renaming things.

That being said, do you actually need to make all the functions return Error? Do you anticipate them all getting reporting some form of error? If you don't, making them return Error complicates the usage and adds some code paths (i.e. a function returning a failed Error) we can't test, because they are dead. Perhaps it would be better to only modify the signature of EmitDebugRanges, since that's where you need the error reported from.

llvm/lib/ObjectYAML/ELFEmitter.cpp

893–895

Rather than just writing handleAllErrors here, I'd move this into a helper function alongside reportError, probably as a reportError overload that takes Error. That would be useful going forwards.

[Higuoxing]

In D81356#2078973, @jhenderson wrote:

To silence all the clang-tidy warnings, I'd be happy if you want to do a bulk renaming of the functions (to emitDebug*) as a separate commit before this patch. Since you're going to modify all those lines in this patch anyway, it'll not make git blame any worse, which is usually the motivation behind not renaming things.

Sure, I will do it later.

That being said, do you actually need to make all the functions return Error? Do you anticipate them all getting reporting some form of error? If you don't, making them return Error complicates the usage and adds some code paths (i.e. a function returning a failed Error) we can't test, because they are dead. Perhaps it would be better to only modify the signature of EmitDebugRanges, since that's where you need the error reported from.

Yes, I need to, but I'm not sure if I really need to. There's a helper function called EmitDebugSectionImpl that takes EmitFuncType as the parameter, where EmitFuncType can be EmitDebugStrings, EmitDebugARanges etc. The EmitDebugXXX functions have to have same return type (See my inline comment).

llvm/lib/ObjectYAML/DWARFEmitter.cpp

333

The EmitDebugXXXX functions have to have same type.

[jhenderson]

Okay, approach looks fine. Just my comments about function renaming and the error handler to address then.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

333

Right, I see, thanks!

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

862

My concern this starts to look a bit bulky. Perhaps something like the following would be better?

uint64_t BeginOffset = OS.tell();
Error Err = Error::success();

if (Name == ".debug_str")
  Err = DWARFYAML::EmitDebugStr(OS, DWARF);
else if (Name == ".debug_aranges")
  Err = DWARFYAML::EmitDebugAranges(OS, DWARF);
...

if (Err)
  return std::move(Err);

[Higuoxing]

Address comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

862

Thanks a lot!

[Higuoxing]

Apply joinErrors() to other code paths.

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

411–429

I think you could simplify this slightly:

Error Err = emitDebugSectionImpl(DI, &DWARFYAML::emitDebugInfo,
                                        "debug_info", DebugSections));

llvm/lib/ObjectYAML/ELFEmitter.cpp

862

Using joinErrors here and below doesn't make much sense, since there is only a single error to worry about. However, I believe you can't just assign to Err here either, as the original Err will be unchecked (even Error::success() needs to be checked before being overwritten/destroyed).

I think the thing to do is close to what @grimar suggested, but with one additional line:

Error Err = Error::success();
cantFail(Err); // Mark as checked before assigning.

if (Name == ".debug_str")
  Err = DWARFYAML::EmitDebugStr(OS, DWARF);
else if (Name == ".debug_aranges")
  Err = DWARFYAML::EmitDebugAranges(OS, DWARF);
...

if (Err)
  return std::move(Err);

llvm/lib/ObjectYAML/MachOEmitter.cpp

301

Same comment as above - all the joinErrors calls don't need to happen, since there is only ever one Error to worry about.

[Higuoxing]

Address comments.

Thanks for reviewing!

llvm/lib/ObjectYAML/ELFEmitter.cpp

862

Oh, thanks a lot. At first, I don't know how to make the Error::success() get checked. So I use joinErrors() everywhere.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

862

However, I believe you can't just assign to Err here either, as the original Err will be unchecked (even Error::success() needs to be checked before being overwritten/destroyed).

I think the following code will invoke and trigger the original Err to be checked:

/// Move-construct an error value. The newly constructed error is considered
/// unchecked, even if the source error had been checked. The original error
/// becomes a checked Success value, regardless of its original state.
Error(Error &&Other) {
  setChecked(true);
  *this = std::move(Other);
}

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

862

I think the following code will invoke and trigger the original Err to be checked:

Am I wrong?

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

862

Ah, I see I am wrong now. Nevermind.

[jhenderson]

LGTM, but please wait for @grimar to confirm too.

[grimar]

LGTM

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

 
 class raw_ostream;
 
 namespace DWARFYAML {
 
 struct Data;
 struct PubSection;
 
-void emitDebugAbbrev(raw_ostream &OS, const Data &DI);
-void emitDebugStr(raw_ostream &OS, const Data &DI);
+Error emitDebugAbbrev(raw_ostream &OS, const Data &DI);
+Error emitDebugStr(raw_ostream &OS, const Data &DI);
 
-void emitDebugAranges(raw_ostream &OS, const Data &DI);
-void emitDebugRanges(raw_ostream &OS, const Data &DI);
-void emitPubSection(raw_ostream &OS, const PubSection &Sect,
+Error emitDebugAranges(raw_ostream &OS, const Data &DI);
+Error emitDebugRanges(raw_ostream &OS, const Data &DI);
+Error emitPubSection(raw_ostream &OS, const PubSection &Sect,
                      bool IsLittleEndian);
-void emitDebugInfo(raw_ostream &OS, const Data &DI);
-void emitDebugLine(raw_ostream &OS, const Data &DI);
+Error emitDebugInfo(raw_ostream &OS, const Data &DI);
+Error emitDebugLine(raw_ostream &OS, const Data &DI);
 
 Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
 emitDebugSections(StringRef YAMLString, bool ApplyFixups = false,
                   bool IsLittleEndian = sys::IsLittleEndianHost);
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_DWARFEMITTER_H

llvm/lib/ObjectYAML/DWARFEmitter.cpp

 
 static void writeInitialLength(const DWARFYAML::InitialLength &Length,
                                raw_ostream &OS, bool IsLittleEndian) {
   writeInteger((uint32_t)Length.TotalLength, OS, IsLittleEndian);
   if (Length.isDWARF64())
     writeInteger((uint64_t)Length.TotalLength64, OS, IsLittleEndian);
 }
 
-void DWARFYAML::emitDebugStr(raw_ostream &OS, const DWARFYAML::Data &DI) {
+Error DWARFYAML::emitDebugStr(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (auto Str : DI.DebugStrings) {
     OS.write(Str.data(), Str.size());
     OS.write('\0');
   }
+
+  return Error::success();
 }
 
-void DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
+Error DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (auto AbbrevDecl : DI.AbbrevDecls) {
     encodeULEB128(AbbrevDecl.Code, OS);
     encodeULEB128(AbbrevDecl.Tag, OS);
     OS.write(AbbrevDecl.Children);
     for (auto Attr : AbbrevDecl.Attributes) {
       encodeULEB128(Attr.Attribute, OS);
       encodeULEB128(Attr.Form, OS);
       if (Attr.Form == dwarf::DW_FORM_implicit_const)
         encodeSLEB128(Attr.Value, OS);
     }
     encodeULEB128(0, OS);
     encodeULEB128(0, OS);
   }
+
+  return Error::success();
 }
 
-void DWARFYAML::emitDebugAranges(raw_ostream &OS, const DWARFYAML::Data &DI) {
+Error DWARFYAML::emitDebugAranges(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (auto Range : DI.ARanges) {
     auto HeaderStart = OS.tell();
     if (Range.Format == dwarf::DWARF64) {
       writeInteger((uint32_t)dwarf::DW_LENGTH_DWARF64, OS, DI.IsLittleEndian);
       writeInteger((uint64_t)Range.Length, OS, DI.IsLittleEndian);
     } else
       writeInteger((uint32_t)Range.Length, OS, DI.IsLittleEndian);
     writeInteger((uint16_t)Range.Version, OS, DI.IsLittleEndian);
     writeInteger((uint32_t)Range.CuOffset, OS, DI.IsLittleEndian);
     writeInteger((uint8_t)Range.AddrSize, OS, DI.IsLittleEndian);
     writeInteger((uint8_t)Range.SegSize, OS, DI.IsLittleEndian);
 
     auto HeaderSize = OS.tell() - HeaderStart;
     auto FirstDescriptor = alignTo(HeaderSize, Range.AddrSize * 2);
     ZeroFillBytes(OS, FirstDescriptor - HeaderSize);
 
     for (auto Descriptor : Range.Descriptors) {
       writeVariableSizedInteger(Descriptor.Address, Range.AddrSize, OS,
                                 DI.IsLittleEndian);
       writeVariableSizedInteger(Descriptor.Length, Range.AddrSize, OS,
                                 DI.IsLittleEndian);
     }
     ZeroFillBytes(OS, Range.AddrSize * 2);
   }
+
+  return Error::success();
 }
 
-void DWARFYAML::emitDebugRanges(raw_ostream &OS, const DWARFYAML::Data &DI) {
+Error DWARFYAML::emitDebugRanges(raw_ostream &OS, const DWARFYAML::Data &DI) {
   const size_t RangesOffset = OS.tell();
   for (auto DebugRanges : DI.DebugRanges) {
     const size_t CurrOffset = OS.tell() - RangesOffset;
     assert(DebugRanges.Offset >= CurrOffset &&
            "Offset should be greater than or equal to the bytes that we have "
            "written");
     if (DebugRanges.Offset > CurrOffset)
       ZeroFillBytes(OS, DebugRanges.Offset - CurrOffset);
     for (auto Entry : DebugRanges.Entries) {
       writeVariableSizedInteger(Entry.LowOffset, DebugRanges.AddrSize, OS,
                                 DI.IsLittleEndian);
       writeVariableSizedInteger(Entry.HighOffset, DebugRanges.AddrSize, OS,
                                 DI.IsLittleEndian);
     }
     ZeroFillBytes(OS, DebugRanges.AddrSize * 2);
   }
+
+  return Error::success();
 }
 
-void DWARFYAML::emitPubSection(raw_ostream &OS,
+Error DWARFYAML::emitPubSection(raw_ostream &OS,
                                 const DWARFYAML::PubSection &Sect,
                                 bool IsLittleEndian) {
   writeInitialLength(Sect.Length, OS, IsLittleEndian);
   writeInteger((uint16_t)Sect.Version, OS, IsLittleEndian);
   writeInteger((uint32_t)Sect.UnitOffset, OS, IsLittleEndian);
   writeInteger((uint32_t)Sect.UnitSize, OS, IsLittleEndian);
   for (auto Entry : Sect.Entries) {
     writeInteger((uint32_t)Entry.DieOffset, OS, IsLittleEndian);
     if (Sect.IsGNUStyle)
       writeInteger((uint32_t)Entry.Descriptor, OS, IsLittleEndian);
     OS.write(Entry.Name.data(), Entry.Name.size());
     OS.write('\0');
   }
+
+  return Error::success();
 }
 
 namespace {
 /// An extension of the DWARFYAML::ConstVisitor which writes compile
 /// units and DIEs to a stream.
 class DumpVisitor : public DWARFYAML::ConstVisitor {
   raw_ostream &OS;
 
protected:
   }
 
 public:
   DumpVisitor(const DWARFYAML::Data &DI, raw_ostream &Out)
       : DWARFYAML::ConstVisitor(DI), OS(Out) {}
 };
 } // namespace
 
-void DWARFYAML::emitDebugInfo(raw_ostream &OS, const DWARFYAML::Data &DI) {
+Error DWARFYAML::emitDebugInfo(raw_ostream &OS, const DWARFYAML::Data &DI) {
   DumpVisitor Visitor(DI, OS);
   Visitor.traverseDebugInfo();
+
+  return Error::success();
 }
 
 static void emitFileEntry(raw_ostream &OS, const DWARFYAML::File &File) {
   OS.write(File.Name.data(), File.Name.size());
   OS.write('\0');
   encodeULEB128(File.DirIdx, OS);
   encodeULEB128(File.ModTime, OS);
   encodeULEB128(File.Length, OS);
 }
 
-void DWARFYAML::emitDebugLine(raw_ostream &OS, const DWARFYAML::Data &DI) {
+Error DWARFYAML::emitDebugLine(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (const auto &LineTable : DI.DebugLines) {
     writeInitialLength(LineTable.Length, OS, DI.IsLittleEndian);
     uint64_t SizeOfPrologueLength = LineTable.Length.isDWARF64() ? 8 : 4;
     writeInteger((uint16_t)LineTable.Version, OS, DI.IsLittleEndian);
     writeVariableSizedInteger(LineTable.PrologueLength, SizeOfPrologueLength,
                               OS, DI.IsLittleEndian);
     writeInteger((uint8_t)LineTable.MinInstLength, OS, DI.IsLittleEndian);
     if (LineTable.Version >= 4)
for (auto Op : LineTable.Opcodes) {
         default:
           for (auto OpData : Op.StandardOpcodeData) {
             encodeULEB128(OpData, OS);
           }
         }
       }
     }
   }
+
+  return Error::success();
 }
 
-using EmitFuncType = void (*)(raw_ostream &, const DWARFYAML::Data &);
+using EmitFuncType = Error (*)(raw_ostream &, const DWARFYAML::Data &);
 
-static void
+static Error
 emitDebugSectionImpl(const DWARFYAML::Data &DI, EmitFuncType EmitFunc,
                      StringRef Sec,
                      StringMap<std::unique_ptr<MemoryBuffer>> &OutputBuffers) {
   std::string Data;
   raw_string_ostream DebugInfoStream(Data);
-  EmitFunc(DebugInfoStream, DI);
+  if (Error Err = EmitFunc(DebugInfoStream, DI))
+    return Err;
   DebugInfoStream.flush();
   if (!Data.empty())
     OutputBuffers[Sec] = MemoryBuffer::getMemBufferCopy(Data);
+
+  return Error::success();
 }
 
 namespace {
 class DIEFixupVisitor : public DWARFYAML::Visitor {
   uint64_t Length;
 
 public:
   DIEFixupVisitor(DWARFYAML::Data &DI) : DWARFYAML::Visitor(DI){};
if (YIn.error())
     return errorCodeToError(YIn.error());
 
   if (ApplyFixups) {
     DIEFixupVisitor DIFixer(DI);
     DIFixer.traverseDebugInfo();
   }
 
   StringMap<std::unique_ptr<MemoryBuffer>> DebugSections;
-  emitDebugSectionImpl(DI, &DWARFYAML::emitDebugInfo, "debug_info",
-                       DebugSections);
-  emitDebugSectionImpl(DI, &DWARFYAML::emitDebugLine, "debug_line",
-                       DebugSections);
-  emitDebugSectionImpl(DI, &DWARFYAML::emitDebugStr, "debug_str",
-                       DebugSections);
-  emitDebugSectionImpl(DI, &DWARFYAML::emitDebugAbbrev, "debug_abbrev",
-                       DebugSections);
-  emitDebugSectionImpl(DI, &DWARFYAML::emitDebugAranges, "debug_aranges",
-                       DebugSections);
-  emitDebugSectionImpl(DI, &DWARFYAML::emitDebugRanges, "debug_ranges",
-                       DebugSections);
+  if (Error Err = emitDebugSectionImpl(DI, &DWARFYAML::emitDebugInfo,
+                                       "debug_info", DebugSections))
+    return std::move(Err);
+  if (Error Err = emitDebugSectionImpl(DI, &DWARFYAML::emitDebugLine,
+                                       "debug_line", DebugSections))
+    return std::move(Err);
+  if (Error Err = emitDebugSectionImpl(DI, &DWARFYAML::emitDebugStr,
+                                       "debug_str", DebugSections))
+    return std::move(Err);
+  if (Error Err = emitDebugSectionImpl(DI, &DWARFYAML::emitDebugAbbrev,
+                                       "debug_abbrev", DebugSections))
+    return std::move(Err);
+  if (Error Err = emitDebugSectionImpl(DI, &DWARFYAML::emitDebugAranges,
+                                       "debug_aranges", DebugSections))
+    return std::move(Err);
+  if (Error Err = emitDebugSectionImpl(DI, &DWARFYAML::emitDebugRanges,
+                                       "debug_ranges", DebugSections))
+    return std::move(Err);
   return std::move(DebugSections);
 }

llvm/lib/ObjectYAML/ELFEmitter.cpp

 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ObjectYAML/DWARFEmitter.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/EndianStream.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
template <class ELFT> class ELFState {
   ELFYAML::Object &Doc;
 
   StringSet<> ExcludedSectionHeaders;
 
   uint64_t LocationCounter = 0;
   bool HasError = false;
   yaml::ErrorHandler ErrHandler;
   void reportError(const Twine &Msg);
+  void reportError(Error Err);
 
   std::vector<Elf_Sym> toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
                                     const StringTableBuilder &Strtab);
   unsigned toSectionIndex(StringRef S, StringRef LocSec, StringRef LocSym = "");
   unsigned toSymbolIndex(StringRef S, StringRef LocSec, bool IsDynamic);
 
   void buildSectionIndex();
   void buildSymbolIndexes();

 }
 
 static bool shouldEmitDWARF(DWARFYAML::Data &DWARF, StringRef Name) {
   SetVector<StringRef> DebugSecNames = DWARF.getUsedSectionNames();
   return Name.consume_front(".") && DebugSecNames.count(Name);
 }
 
 template <class ELFT>
-uint64_t emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name,
+Expected<uint64_t> emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name,
                              const DWARFYAML::Data &DWARF, raw_ostream &OS) {
   uint64_t BeginOffset = OS.tell();
+  Error Err = Error::success();
+
   if (Name == ".debug_str")
-    DWARFYAML::emitDebugStr(OS, DWARF);
+    Err = joinErrors(std::move(Err), DWARFYAML::emitDebugStr(OS, DWARF));
   else if (Name == ".debug_aranges")
-    DWARFYAML::emitDebugAranges(OS, DWARF);
+    Err = joinErrors(std::move(Err), DWARFYAML::emitDebugAranges(OS, DWARF));
   else if (Name == ".debug_ranges")
-    DWARFYAML::emitDebugRanges(OS, DWARF);
+    Err = joinErrors(std::move(Err), DWARFYAML::emitDebugRanges(OS, DWARF));
   else
     llvm_unreachable("unexpected emitDWARF() call");
 
+  if (Err)
+    return std::move(Err);
+
   return OS.tell() - BeginOffset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                             ContiguousBlobAccumulator &CBA,
                                             ELFYAML::Section *YAMLSec) {
   zero(SHeader);
   SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name));
   SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS;
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
   SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
                                     YAMLSec ? YAMLSec->Offset : None);
 
   ELFYAML::RawContentSection *RawSec =
       dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
   if (Doc.DWARF && shouldEmitDWARF(*Doc.DWARF, Name)) {
     if (RawSec && (RawSec->Content || RawSec->Size))
       reportError("cannot specify section '" + Name +
                   "' contents in the 'DWARF' entry and the 'Content' "
                   "or 'Size' in the 'Sections' entry at the same time");
+    else {
+      if (Expected<uint64_t> ShSizeOrErr =
+              emitDWARF<ELFT>(SHeader, Name, *Doc.DWARF, CBA.getOS()))
+        SHeader.sh_size = *ShSizeOrErr;
       else
-      SHeader.sh_size = emitDWARF<ELFT>(SHeader, Name, *Doc.DWARF, CBA.getOS());
+        reportError(ShSizeOrErr.takeError());
+    }
   } else if (RawSec)
     SHeader.sh_size = writeContent(CBA.getOS(), RawSec->Content, RawSec->Size);
   else
     llvm_unreachable("debug sections can only be initialized via the 'DWARF' "
                      "entry or a RawContentSection");
 
   if (YAMLSec && YAMLSec->EntSize)
     SHeader.sh_entsize = *YAMLSec->EntSize;
   else if (Name == ".debug_str")
void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   assignSectionAddress(SHeader, YAMLSec);
 }
 
 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;
 }
 
+template <class ELFT> void ELFState<ELFT>::reportError(Error Err) {
+  handleAllErrors(std::move(Err), [&](const ErrorInfoBase &Err) {
+    reportError(Err.message());
+  });
+}
+
 template <class ELFT>
 std::vector<Fragment>
 ELFState<ELFT>::getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
                                  ArrayRef<Elf_Shdr> SHeaders) {
   std::vector<Fragment> Ret;
   for (const ELFYAML::Chunk *C : Phdr.Chunks) {
     if (const ELFYAML::Fill *F = dyn_cast<ELFYAML::Fill>(C)) {
       Ret.push_back({*F->Offset, F->Size, llvm::ELF::SHT_PROGBITS,

llvm/lib/ObjectYAML/MachOEmitter.cpp

case MachO::LC_SEGMENT_64:
         // Zero Fill any data between the end of the last thing we wrote and the
         // start of this section.
         if (OS.tell() - fileStart > Sec.offset && Sec.offset != (uint32_t)0)
           return createStringError(
               errc::invalid_argument,
               "wrote too much data somewhere, section offsets don't line up");
         if (0 == strncmp(&Sec.segname[0], "__DWARF", 16)) {
           if (0 == strncmp(&Sec.sectname[0], "__debug_str", 16)) {
-            DWARFYAML::emitDebugStr(OS, Obj.DWARF);
+            if (Error Err = DWARFYAML::emitDebugStr(OS, Obj.DWARF))
+              return Err;
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_abbrev", 16)) {
-            DWARFYAML::emitDebugAbbrev(OS, Obj.DWARF);
+            if (Error Err = DWARFYAML::emitDebugAbbrev(OS, Obj.DWARF))
+              return Err;
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_aranges", 16)) {
-            DWARFYAML::emitDebugAranges(OS, Obj.DWARF);
+            if (Error Err = DWARFYAML::emitDebugAranges(OS, Obj.DWARF))
+              return Err;
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_ranges", 16)) {
-            DWARFYAML::emitDebugRanges(OS, Obj.DWARF);
+            if (Error Err = DWARFYAML::emitDebugRanges(OS, Obj.DWARF))
+              return Err;
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubnames", 16)) {
             if (Obj.DWARF.PubNames)
-              DWARFYAML::emitPubSection(OS, *Obj.DWARF.PubNames,
-                                        Obj.IsLittleEndian);
+              if (Error Err = DWARFYAML::emitPubSection(OS, *Obj.DWARF.PubNames,
+                                                        Obj.IsLittleEndian))
+                return Err;
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubtypes", 16)) {
             if (Obj.DWARF.PubTypes)
-              DWARFYAML::emitPubSection(OS, *Obj.DWARF.PubTypes,
-                                        Obj.IsLittleEndian);
+              if (Error Err = DWARFYAML::emitPubSection(OS, *Obj.DWARF.PubTypes,
+                                                        Obj.IsLittleEndian))
+                return Err;
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_info", 16)) {
-            DWARFYAML::emitDebugInfo(OS, Obj.DWARF);
+            if (Error Err = DWARFYAML::emitDebugInfo(OS, Obj.DWARF))
+              return Err;
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_line", 16)) {
-            DWARFYAML::emitDebugLine(OS, Obj.DWARF);
+            if (Error Err = DWARFYAML::emitDebugLine(OS, Obj.DWARF))
+              return Err;
           }
 
           continue;
         }
 
         // Skip if it's a virtual section.
         if (MachO::isVirtualSection(Sec.flags & MachO::SECTION_TYPE))
           continue;