[yaml2obj/ObjectYAML] - Cleanup the error reporting API, add custom errors handlers.

[grimar]

Summary

This is a continuation of the YAML library error reporting
refactoring/improvement and the idea by itself was mentioned
in the following thread:
https://reviews.llvm.org/D67182?id=218714#inline-603404

This performs a cleanup of all object emitters in the library.
It allows using the custom one provided by the caller.

One of the nice things is that each tool can now print its tool name,
e.g: "yaml2obj: error: <text>"

Also, the code became a bit simpler.

[sbc100]

include/llvm/ObjectYAML/yaml2obj.h

49

It seems like there is a separate change here which is to convert a lot of return codes from "int -> 0 for success" to "bool -> 1 for success". Is that objectively better? Is there an llvm policy for which is preferred? Could this change be more precise if that part was split out?

lib/ObjectYAML/yaml2obj.cpp

21

I don't see this function referenced anywhere.

[grimar]

include/llvm/ObjectYAML/yaml2obj.h

49

I believe it is better because we only use 1 and 0. There are no another values => the valid type to represent it should be bool. I never heard about policies about the returning types in the libraries. And it is a bit hard to imagine one that would say to use int when we can use bool :)

I am OK to split it out I think, I am not sure if it can make this diff much shorter/easier to read, but I'll try.

lib/ObjectYAML/yaml2obj.cpp

21

Oh, you're right, thanks. I forgot to remove it. At first I experimenmted with the logic that used a default handler if no handler was provided, but then removed it. It seems that it is OK to always provide the custom one.

[jhenderson]

Broadly looks fine to me.

include/llvm/ObjectYAML/yaml2obj.h

47

using instead of typedef maybe?

lib/ObjectYAML/MachOEmitter.cpp

18

I haven't yet looked at the other files, but this seems like an unnecessary include, right?

lib/ObjectYAML/WasmEmitter.cpp

130

clang-format?

unittests/ObjectYAML/YAML2ObjTest.cpp

60

Delete "the"

69

Delete "the"

82

No newline at end of file

[sbc100]

include/llvm/ObjectYAML/yaml2obj.h

49

I think its mostly a split between the old school C-style APIs where zero means success and non-zero means failure. I'm not sure how relevant this is in modern C++ codebases though.. perhaps not at all.

[MaskRay]

lib/ObjectYAML/COFFEmitter.cpp

84

I see is below so I'm thinking whether we should use gets here.

lib/ObjectYAML/MachOEmitter.cpp

390

Probably make a separate change to convert typedef to using.

test/tools/yaml2obj/dynsymtab-implicit-sections-size-content.yaml

34

yaml2obj: is prepended to a few error messages. In llvm-readobj/llvm-objcopy/llvm-objdump, I think we leave out the tool name?

tools/yaml2obj/yaml2obj.cpp

56

or failed to open.

failed to parse is used in yaml2coff.

unittests/ObjectYAML/YAML2ObjTest.cpp

77

Res can be deleted.

[grimar]

• Addressed review comments.
• Now rebased on top of D67488.

include/llvm/ObjectYAML/yaml2obj.h

47

Ok.

lib/ObjectYAML/COFFEmitter.cpp

84

I guess both of spellings make sense. But these messages are far from ideal. I think reporting "section alignment is too large" or "string table is/got too large" without mentioning at least the name of a section is not too usefull anyways. I'd leave them alone for now.

lib/ObjectYAML/MachOEmitter.cpp

18

Yes, removed.

390

LLVM heavily uses typedefs too, so I guess it is not a real problem.
New code probably should use using though.

lib/ObjectYAML/WasmEmitter.cpp

130

Yep.

test/tools/yaml2obj/dynsymtab-implicit-sections-size-content.yaml

34

I added it here because test on the left had "yaml2obj failed" message and now we do not have it.
So I wanted to show the whole difference.
Generally I think we should not include testing of the tool name everywhere.

I added it to tests like "invalid-docnum.test" and "empty-or-invalid-doc.yaml" below though, since they
test the basic functionality and reporting the tool name is a basic thing that should be checked at least for basic messages perhaps.

But generally I do not have a strong feeling about how we should test this, so can remove it, though do not see a problem to keep it too.

tools/yaml2obj/yaml2obj.cpp

56

Ok.

unittests/ObjectYAML/YAML2ObjTest.cpp

77

Probably not, because we want to test that convertYAML doesn't return true when there are errors.

[jhenderson]

LGTM, but best wait for others to confirm they're happy.

[sbc100]

lib/ObjectYAML/MachOEmitter.cpp

70

So it seems like this isn't quiet a NFC since the writers in general now always continue to try to write part of the object file even after an error occurs? This seems slightly worse, although I can't think of case where it would be real problem. Assuming that is the desired effect and the consequences have been considered then I'm OK with change in general since it does seem the make the core simpler.

[grimar]

lib/ObjectYAML/MachOEmitter.cpp

70

So it seems like this isn't quiet a NFC since the writers in general now always continue to try to write part of the object file even after an error occurs?

For now this change is NFC, because writers never return anything rather than Error::success().
If we will need to stop writing on error in future, we might add something like

if (HasError)
  return;

to any place we want.

include/llvm/ObjectYAML/yaml2obj.h

 namespace WasmYAML {
 struct Object;
 }
 
 namespace yaml {
 class Input;
 struct YamlObjectFile;
 
-int yaml2coff(COFFYAML::Object &Doc, raw_ostream &Out);
-int yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out);
-int yaml2macho(YamlObjectFile &Doc, raw_ostream &Out);
-int yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out);
-int yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out);
+typedef llvm::function_ref<void(const Twine &Msg)> ErrorHandler;
 
-Error convertYAML(Input &YIn, raw_ostream &Out, unsigned DocNum = 1);
+bool yaml2coff(COFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
+bool yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
+bool yaml2macho(YamlObjectFile &Doc, raw_ostream &Out, ErrorHandler EH);
+bool yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out,
+                   ErrorHandler EH);
+bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
+
+bool convertYAML(Input &YIn, raw_ostream &Out, ErrorHandler ErrHandler,
+                 unsigned DocNum = 1);
 
 /// Convenience function for tests.
-Expected<std::unique_ptr<object::ObjectFile>>
-yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml);
+std::unique_ptr<object::ObjectFile>
+yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml,
+                ErrorHandler ErrHandler);
 
 } // namespace yaml
 } // namespace llvm
 
 #endif

lib/ObjectYAML/COFFEmitter.cpp

 
 using namespace llvm;
 
 namespace {
 
 /// This parses a yaml stream that represents a COFF object file.
 /// See docs/yaml2obj for the yaml scheema.
 struct COFFParser {
-  COFFParser(COFFYAML::Object &Obj)
-      : Obj(Obj), SectionTableStart(0), SectionTableSize(0) {
+  COFFParser(COFFYAML::Object &Obj, yaml::ErrorHandler EH)
+      : Obj(Obj), SectionTableStart(0), SectionTableSize(0), ErrHandler(EH) {
     // A COFF string table always starts with a 4 byte size field. Offsets into
     // it include this size, so allocate it now.
     StringTable.append(4, char(0));
   }
 
   bool useBigObj() const {
     return static_cast<int32_t>(Obj.Sections.size()) >
            COFF::MaxNumberOfSections16;
for (std::vector<COFFYAML::Section>::iterator i = Obj.Sections.begin(),
 
       if (Name.size() <= COFF::NameSize) {
         std::copy(Name.begin(), Name.end(), Sec.Header.Name);
       } else {
         // Add string to the string table and format the index for output.
         unsigned Index = getStringIndex(Name);
         std::string str = utostr(Index);
         if (str.size() > 7) {
-          errs() << "String table got too large\n";
+          ErrHandler("string table got too large");
           return false;
         }
         Sec.Header.Name[0] = '/';
         std::copy(str.begin(), str.end(), Sec.Header.Name + 1);
       }
 
       if (Sec.Alignment) {
         if (Sec.Alignment > 8192) {
-          errs() << "Section alignment is too large\n";
+          ErrHandler("section alignment is too large");
           return false;
         }
         if (!isPowerOf2_32(Sec.Alignment)) {
-          errs() << "Section alignment is not a power of 2\n";
+          ErrHandler("section alignment is not a power of 2");
           return false;
         }
         Sec.Header.Characteristics |= (Log2_32(Sec.Alignment) + 1) << 20;
       }
     }
     return true;
   }
 
struct COFFParser {
   COFFYAML::Object &Obj;
 
   codeview::StringsAndChecksums StringsAndChecksums;
   BumpPtrAllocator Allocator;
   StringMap<unsigned> StringTableMap;
   std::string StringTable;
   uint32_t SectionTableStart;
   uint32_t SectionTableSize;
+
+  yaml::ErrorHandler ErrHandler;
 };
 
 enum { DOSStubSize = 128 };
 
 } // end anonymous namespace
 
 // Take a CP and assign addresses and sizes to everything. Returns false if the
 // layout is not valid to do.
static bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
   if (CP.Obj.Header.PointerToSymbolTable)
     OS.write(&CP.StringTable[0], CP.StringTable.size());
   return true;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out) {
-  COFFParser CP(Doc);
+bool yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out,
+               ErrorHandler ErrHandler) {
+  COFFParser CP(Doc, ErrHandler);
   if (!CP.parse()) {
-    errs() << "yaml2obj: Failed to parse YAML file!\n";
-    return 1;
+    ErrHandler("failed to parse YAML file");
+    return false;
   }
 
   if (!layoutOptionalHeader(CP)) {
-    errs() << "yaml2obj: Failed to layout optional header for COFF file!\n";
-    return 1;
+    ErrHandler("failed to layout optional header for COFF file");
+    return false;
   }
 
   if (!layoutCOFF(CP)) {
-    errs() << "yaml2obj: Failed to layout COFF file!\n";
-    return 1;
+    ErrHandler("failed to layout COFF file");
+    return false;
   }
   if (!writeCOFF(CP, Out)) {
-    errs() << "yaml2obj: Failed to write COFF file!\n";
-    return 1;
+    ErrHandler("failed to write COFF file");
+    return false;
   }
-  return 0;
+  return true;
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> class ELFState {
   StringTableBuilder DotDynstr{StringTableBuilder::ELF};
 
   NameToIdxMap SN2I;
   NameToIdxMap SymN2I;
   NameToIdxMap DynSymN2I;
   ELFYAML::Object &Doc;
 
   bool HasError = false;
+  yaml::ErrorHandler ErrHandler;
+  void reportError(const Twine &Msg);
 
   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 reportError(const Twine &Msg);
 
   void buildSectionIndex();
   void buildSymbolIndexes();
   void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
   bool initImplicitHeader(ContiguousBlobAccumulator &CBA, Elf_Shdr &Header,
                           StringRef SecName, ELFYAML::Section *YAMLSec);
   void initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                           ContiguousBlobAccumulator &CBA);
void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::VerdefSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
-  ELFState(ELFYAML::Object &D);
+  ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
+
 public:
-  static int writeELF(raw_ostream &OS, ELFYAML::Object &Doc);
+  static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
+                       yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
 
 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
   return A.size() * sizeof(T);
 }
 
 template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
   OS.write((const char *)A.data(), arrayDataSize(A));
 }
 
 template <class T> static void zero(T &Obj) { memset(&Obj, 0, sizeof(Obj)); }
 
-template <class ELFT> ELFState<ELFT>::ELFState(ELFYAML::Object &D) : Doc(D) {
+template <class ELFT>
+ELFState<ELFT>::ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH)
+    : Doc(D), ErrHandler(EH) {
   StringSet<> DocSections;
   for (std::unique_ptr<ELFYAML::Section> &D : Doc.Sections)
     if (!D->Name.empty())
       DocSections.insert(D->Name);
 
   // Insert SHT_NULL section implicitly when it is not defined in YAML.
   if (Doc.Sections.empty() || Doc.Sections.front()->Type != ELF::SHT_NULL)
     Doc.Sections.insert(
void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
 
   // If the section is explicitly described in the YAML
   // then we want to use its section address.
   if (YAMLSec)
     SHeader.sh_addr = YAMLSec->Address;
 }
 
 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
-  WithColor::error() << Msg << "\n";
+  ErrHandler(Msg);
   HasError = true;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                                             std::vector<Elf_Shdr> &SHeaders) {
   uint32_t PhdrIdx = 0;
   for (auto &YamlPhdr : Doc.ProgramHeaders) {
if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec.get())) {
           DotDynstr.add(Name);
     }
   }
 
   DotDynstr.finalize();
 }
 
 template <class ELFT>
-int ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc) {
-  ELFState<ELFT> State(Doc);
+bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
+                              yaml::ErrorHandler EH) {
+  ELFState<ELFT> State(Doc, EH);
 
   // Finalize .strtab and .dynstr sections. We do that early because want to
   // finalize the string table builders before writing the content of the
   // sections that might want to use them.
   State.finalizeStrings();
 
   State.buildSectionIndex();
   State.buildSymbolIndexes();
bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
 
   std::vector<Elf_Shdr> SHeaders;
   State.initSectionHeaders(SHeaders, CBA);
 
   // Now we can decide segment offsets
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
   if (State.HasError)
-    return 1;
+    return false;
 
   State.writeELFHeader(CBA, OS);
   writeArrayData(OS, makeArrayRef(PHeaders));
   CBA.writeBlobToStream(OS);
   writeArrayData(OS, makeArrayRef(SHeaders));
-  return 0;
+  return true;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out) {
+bool yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH) {
   bool IsLE = Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
   bool Is64Bit = Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
   if (Is64Bit) {
     if (IsLE)
-      return ELFState<object::ELF64LE>::writeELF(Out, Doc);
-    return ELFState<object::ELF64BE>::writeELF(Out, Doc);
+      return ELFState<object::ELF64LE>::writeELF(Out, Doc, EH);
+    return ELFState<object::ELF64BE>::writeELF(Out, Doc, EH);
   }
   if (IsLE)
-    return ELFState<object::ELF32LE>::writeELF(Out, Doc);
-  return ELFState<object::ELF32BE>::writeELF(Out, Doc);
+    return ELFState<object::ELF32LE>::writeELF(Out, Doc, EH);
+  return ELFState<object::ELF32BE>::writeELF(Out, Doc, EH);
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/MachOEmitter.cpp

 /// The Mach component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/ObjectYAML/DWARFEmitter.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 
 namespace {
 
 class MachOWriter {
 public:
   MachOWriter(MachOYAML::Object &Obj) : Obj(Obj), is64Bit(true), fileStart(0) {
     is64Bit = Obj.Header.magic == MachO::MH_MAGIC_64 ||
               Obj.Header.magic == MachO::MH_CIGAM_64;
     memset(reinterpret_cast<void *>(&Header), 0, sizeof(MachO::mach_header_64));
   }
 
-  Error writeMachO(raw_ostream &OS);
+  void writeMachO(raw_ostream &OS);
 
 private:
-  Error writeHeader(raw_ostream &OS);
-  Error writeLoadCommands(raw_ostream &OS);
-  Error writeSectionData(raw_ostream &OS);
-  Error writeLinkEditData(raw_ostream &OS);
+  void writeHeader(raw_ostream &OS);
+  void writeLoadCommands(raw_ostream &OS);
+  void writeSectionData(raw_ostream &OS);
+  void writeLinkEditData(raw_ostream &OS);
 
   void writeBindOpcodes(raw_ostream &OS,
                         std::vector<MachOYAML::BindOpcode> &BindOpcodes);
   // LinkEdit writers
-  Error writeRebaseOpcodes(raw_ostream &OS);
-  Error writeBasicBindOpcodes(raw_ostream &OS);
-  Error writeWeakBindOpcodes(raw_ostream &OS);
-  Error writeLazyBindOpcodes(raw_ostream &OS);
-  Error writeNameList(raw_ostream &OS);
-  Error writeStringTable(raw_ostream &OS);
-  Error writeExportTrie(raw_ostream &OS);
+  void writeRebaseOpcodes(raw_ostream &OS);
+  void writeBasicBindOpcodes(raw_ostream &OS);
+  void writeWeakBindOpcodes(raw_ostream &OS);
+  void writeLazyBindOpcodes(raw_ostream &OS);
+  void writeNameList(raw_ostream &OS);
+  void writeStringTable(raw_ostream &OS);
+  void writeExportTrie(raw_ostream &OS);
 
   void dumpExportEntry(raw_ostream &OS, MachOYAML::ExportEntry &Entry);
   void ZeroToOffset(raw_ostream &OS, size_t offset);
 
   MachOYAML::Object &Obj;
   bool is64Bit;
   uint64_t fileStart;
 
   MachO::mach_header_64 Header;
 };
 
-Error MachOWriter::writeMachO(raw_ostream &OS) {
+void MachOWriter::writeMachO(raw_ostream &OS) {
   fileStart = OS.tell();
-  if (auto Err = writeHeader(OS))
-    return Err;
-  if (auto Err = writeLoadCommands(OS))
-    return Err;
-  if (auto Err = writeSectionData(OS))
-    return Err;
-  return Error::success();
+  writeHeader(OS);
+  writeLoadCommands(OS);
+  writeSectionData(OS);
 }
 
-Error MachOWriter::writeHeader(raw_ostream &OS) {
+void MachOWriter::writeHeader(raw_ostream &OS) {
   Header.magic = Obj.Header.magic;
   Header.cputype = Obj.Header.cputype;
   Header.cpusubtype = Obj.Header.cpusubtype;
   Header.filetype = Obj.Header.filetype;
   Header.ncmds = Obj.Header.ncmds;
   Header.sizeofcmds = Obj.Header.sizeofcmds;
   Header.flags = Obj.Header.flags;
   Header.reserved = Obj.Header.reserved;
 
   if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
     MachO::swapStruct(Header);
 
   auto header_size =
       is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
   OS.write((const char *)&Header, header_size);
-
-  return Error::success();
 }
 
 template <typename SectionType>
 SectionType constructSection(MachOYAML::Section Sec) {
   SectionType TempSec;
   memcpy(reinterpret_cast<void *>(&TempSec.sectname[0]), &Sec.sectname[0], 16);
   memcpy(reinterpret_cast<void *>(&TempSec.segname[0]), &Sec.segname[0], 16);
   TempSec.addr = Sec.addr;

 }
 
 void MachOWriter::ZeroToOffset(raw_ostream &OS, size_t Offset) {
   auto currOffset = OS.tell() - fileStart;
   if (currOffset < Offset)
     ZeroFillBytes(OS, Offset - currOffset);
 }
 
-Error MachOWriter::writeLoadCommands(raw_ostream &OS) {
+void MachOWriter::writeLoadCommands(raw_ostream &OS) {
   for (auto &LC : Obj.LoadCommands) {
     size_t BytesWritten = 0;
     llvm::MachO::macho_load_command Data = LC.Data;
 
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
   case MachO::LCName:                                                          \
     if (Obj.IsLittleEndian != sys::IsLittleEndianHost)                         \
       MachO::swapStruct(Data.LCStruct##_data);                                 \
#include "llvm/BinaryFormat/MachO.def"
 
     // Fill remaining bytes with 0. This will only get hit in partially
     // specified test cases.
     auto BytesRemaining = LC.Data.load_command_data.cmdsize - BytesWritten;
     if (BytesRemaining > 0) {
       ZeroFillBytes(OS, BytesRemaining);
     }
   }
-  return Error::success();
 }
 
-Error MachOWriter::writeSectionData(raw_ostream &OS) {
+void MachOWriter::writeSectionData(raw_ostream &OS) {
   bool FoundLinkEditSeg = false;
   for (auto &LC : Obj.LoadCommands) {
     switch (LC.Data.load_command_data.cmd) {
     case MachO::LC_SEGMENT:
     case MachO::LC_SEGMENT_64:
       uint64_t segOff = is64Bit ? LC.Data.segment_command_64_data.fileoff
                                 : LC.Data.segment_command_data.fileoff;
       if (0 ==
           strncmp(&LC.Data.segment_command_data.segname[0], "__LINKEDIT", 16)) {
         FoundLinkEditSeg = true;
-        if (auto Err = writeLinkEditData(OS))
-          return Err;
+        writeLinkEditData(OS);
       }
       for (auto &Sec : LC.Sections) {
         ZeroToOffset(OS, Sec.offset);
         // Zero Fill any data between the end of the last thing we wrote and the
         // start of this section.
         assert((OS.tell() - fileStart <= Sec.offset ||
                 Sec.offset == (uint32_t)0) &&
                "Wrote too much data somewhere, section offsets don't line up.");
case MachO::LC_SEGMENT_64:
       uint64_t segSize = is64Bit ? LC.Data.segment_command_64_data.filesize
                                  : LC.Data.segment_command_data.filesize;
       ZeroToOffset(OS, segOff + segSize);
       break;
     }
   }
   // Old PPC Object Files didn't have __LINKEDIT segments, the data was just
   // stuck at the end of the file.
-  if (!FoundLinkEditSeg) {
-    if (auto Err = writeLinkEditData(OS))
-      return Err;
-  }
-  return Error::success();
+  if (!FoundLinkEditSeg)
+    writeLinkEditData(OS);
 }
 
 void MachOWriter::writeBindOpcodes(
     raw_ostream &OS, std::vector<MachOYAML::BindOpcode> &BindOpcodes) {
 
   for (auto Opcode : BindOpcodes) {
     uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
     OS.write(reinterpret_cast<char *>(&OpByte), 1);
for (auto EE : Entry.Children) {
     OS << EE.Name;
     OS.write('\0');
     encodeSLEB128(EE.NodeOffset, OS);
   }
   for (auto EE : Entry.Children)
     dumpExportEntry(OS, EE);
 }
 
-Error MachOWriter::writeExportTrie(raw_ostream &OS) {
+void MachOWriter::writeExportTrie(raw_ostream &OS) {
   dumpExportEntry(OS, Obj.LinkEdit.ExportTrie);
-  return Error::success();
 }
 
 template <typename NListType>
 void writeNListEntry(MachOYAML::NListEntry &NLE, raw_ostream &OS,
                      bool IsLittleEndian) {
   NListType ListEntry;
   ListEntry.n_strx = NLE.n_strx;
   ListEntry.n_type = NLE.n_type;
   ListEntry.n_sect = NLE.n_sect;
   ListEntry.n_desc = NLE.n_desc;
   ListEntry.n_value = NLE.n_value;
 
   if (IsLittleEndian != sys::IsLittleEndianHost)
     MachO::swapStruct(ListEntry);
   OS.write(reinterpret_cast<const char *>(&ListEntry), sizeof(NListType));
 }
 
-Error MachOWriter::writeLinkEditData(raw_ostream &OS) {
-  typedef Error (MachOWriter::*writeHandler)(raw_ostream &);
+void MachOWriter::writeLinkEditData(raw_ostream &OS) {
+  typedef void (MachOWriter::*writeHandler)(raw_ostream &);
   typedef std::pair<uint64_t, writeHandler> writeOperation;
   std::vector<writeOperation> WriteQueue;
 
   MachO::dyld_info_command *DyldInfoOnlyCmd = 0;
   MachO::symtab_command *SymtabCmd = 0;
   for (auto &LC : Obj.LoadCommands) {
     switch (LC.Data.load_command_data.cmd) {
     case MachO::LC_SYMTAB:
       SymtabCmd = &LC.Data.symtab_command_data;
void MachOWriter::writeLinkEditData(raw_ostream &OS) {
   }
 
   llvm::sort(WriteQueue, [](const writeOperation &a, const writeOperation &b) {
     return a.first < b.first;
   });
 
   for (auto writeOp : WriteQueue) {
     ZeroToOffset(OS, writeOp.first);
-    if (auto Err = (this->*writeOp.second)(OS))
-      return Err;
+    (this->*writeOp.second)(OS);
   }
-
-  return Error::success();
 }
 
-Error MachOWriter::writeRebaseOpcodes(raw_ostream &OS) {
+void MachOWriter::writeRebaseOpcodes(raw_ostream &OS) {
   MachOYAML::LinkEditData &LinkEdit = Obj.LinkEdit;
 
   for (auto Opcode : LinkEdit.RebaseOpcodes) {
     uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
     OS.write(reinterpret_cast<char *>(&OpByte), 1);
-    for (auto Data : Opcode.ExtraData) {
+    for (auto Data : Opcode.ExtraData)
       encodeULEB128(Data, OS);
-    }
-  }
-  return Error::success();
-}
 
-Error MachOWriter::writeBasicBindOpcodes(raw_ostream &OS) {
+void MachOWriter::writeBasicBindOpcodes(raw_ostream &OS) {
   writeBindOpcodes(OS, Obj.LinkEdit.BindOpcodes);
-  return Error::success();
 }
 
-Error MachOWriter::writeWeakBindOpcodes(raw_ostream &OS) {
+void MachOWriter::writeWeakBindOpcodes(raw_ostream &OS) {
   writeBindOpcodes(OS, Obj.LinkEdit.WeakBindOpcodes);
-  return Error::success();
 }
 
-Error MachOWriter::writeLazyBindOpcodes(raw_ostream &OS) {
+void MachOWriter::writeLazyBindOpcodes(raw_ostream &OS) {
   writeBindOpcodes(OS, Obj.LinkEdit.LazyBindOpcodes);
-  return Error::success();
 }
 
-Error MachOWriter::writeNameList(raw_ostream &OS) {
+void MachOWriter::writeNameList(raw_ostream &OS) {
   for (auto NLE : Obj.LinkEdit.NameList) {
     if (is64Bit)
       writeNListEntry<MachO::nlist_64>(NLE, OS, Obj.IsLittleEndian);
     else
       writeNListEntry<MachO::nlist>(NLE, OS, Obj.IsLittleEndian);
   }
-  return Error::success();
 }
 
-Error MachOWriter::writeStringTable(raw_ostream &OS) {
+void MachOWriter::writeStringTable(raw_ostream &OS) {
   for (auto Str : Obj.LinkEdit.StringTable) {
     OS.write(Str.data(), Str.size());
     OS.write('\0');
   }
-  return Error::success();
 }
 
 class UniversalWriter {
 public:
   UniversalWriter(yaml::YamlObjectFile &ObjectFile)
       : ObjectFile(ObjectFile), fileStart(0) {}
 
-  Error writeMachO(raw_ostream &OS);
+  void writeMachO(raw_ostream &OS);
 
 private:
-  Error writeFatHeader(raw_ostream &OS);
-  Error writeFatArchs(raw_ostream &OS);
+  void writeFatHeader(raw_ostream &OS);
+  void writeFatArchs(raw_ostream &OS);
 
   void ZeroToOffset(raw_ostream &OS, size_t offset);
 
   yaml::YamlObjectFile &ObjectFile;
   uint64_t fileStart;
 };
 
-Error UniversalWriter::writeMachO(raw_ostream &OS) {
+void UniversalWriter::writeMachO(raw_ostream &OS) {
   fileStart = OS.tell();
   if (ObjectFile.MachO) {
     MachOWriter Writer(*ObjectFile.MachO);
-    return Writer.writeMachO(OS);
+    Writer.writeMachO(OS);
+    return;
   }
-  if (auto Err = writeFatHeader(OS))
-    return Err;
-  if (auto Err = writeFatArchs(OS))
-    return Err;
+
+  writeFatHeader(OS);
+  writeFatArchs(OS);
+
   auto &FatFile = *ObjectFile.FatMachO;
   assert(FatFile.FatArchs.size() == FatFile.Slices.size());
   for (size_t i = 0; i < FatFile.Slices.size(); i++) {
     ZeroToOffset(OS, FatFile.FatArchs[i].offset);
     MachOWriter Writer(FatFile.Slices[i]);
-    if (auto Err = Writer.writeMachO(OS))
-      return Err;
+    Writer.writeMachO(OS);
+
     auto SliceEnd = FatFile.FatArchs[i].offset + FatFile.FatArchs[i].size;
     ZeroToOffset(OS, SliceEnd);
   }
-  return Error::success();
 }
 
-Error UniversalWriter::writeFatHeader(raw_ostream &OS) {
+void UniversalWriter::writeFatHeader(raw_ostream &OS) {
   auto &FatFile = *ObjectFile.FatMachO;
   MachO::fat_header header;
   header.magic = FatFile.Header.magic;
   header.nfat_arch = FatFile.Header.nfat_arch;
   if (sys::IsLittleEndianHost)
     swapStruct(header);
   OS.write(reinterpret_cast<const char *>(&header), sizeof(MachO::fat_header));
-  return Error::success();
 }
 
 template <typename FatArchType>
 FatArchType constructFatArch(MachOYAML::FatArch &Arch) {
   FatArchType FatArch;
   FatArch.cputype = Arch.cputype;
   FatArch.cpusubtype = Arch.cpusubtype;
   FatArch.offset = Arch.offset;
void writeFatArch<MachO::fat_arch_64>(MachOYAML::FatArch &Arch,
   auto FatArch = constructFatArch<MachO::fat_arch_64>(Arch);
   FatArch.reserved = Arch.reserved;
   if (sys::IsLittleEndianHost)
     swapStruct(FatArch);
   OS.write(reinterpret_cast<const char *>(&FatArch),
            sizeof(MachO::fat_arch_64));
 }
 
-Error UniversalWriter::writeFatArchs(raw_ostream &OS) {
+void UniversalWriter::writeFatArchs(raw_ostream &OS) {
   auto &FatFile = *ObjectFile.FatMachO;
   bool is64Bit = FatFile.Header.magic == MachO::FAT_MAGIC_64;
   for (auto Arch : FatFile.FatArchs) {
     if (is64Bit)
       writeFatArch<MachO::fat_arch_64>(Arch, OS);
     else
       writeFatArch<MachO::fat_arch>(Arch, OS);
   }
-
-  return Error::success();
 }
 
 void UniversalWriter::ZeroToOffset(raw_ostream &OS, size_t Offset) {
   auto currOffset = OS.tell() - fileStart;
   if (currOffset < Offset)
     ZeroFillBytes(OS, Offset - currOffset);
 }
 
 } // end anonymous namespace
 
 namespace llvm {
 namespace yaml {
 
-int yaml2macho(YamlObjectFile &Doc, raw_ostream &Out) {
+bool yaml2macho(YamlObjectFile &Doc, raw_ostream &Out, ErrorHandler /*EH*/) {
   UniversalWriter Writer(Doc);
-  if (auto Err = Writer.writeMachO(Out)) {
-    errs() << toString(std::move(Err));
-    return 1;
-  }
-  return 0;
+  Writer.writeMachO(Out);
+  return true;
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/MinidumpEmitter.cpp

static Directory layout(BlobAllocator &File, Stream &S) {
   Result.Location.DataSize =
       DataEnd.getValueOr(File.tell()) - Result.Location.RVA;
   return Result;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2minidump(MinidumpYAML::Object &Obj, raw_ostream &Out) {
+bool yaml2minidump(MinidumpYAML::Object &Obj, raw_ostream &Out,
+                   ErrorHandler /*EH*/) {
   BlobAllocator File;
   File.allocateObject(Obj.Header);
 
   std::vector<Directory> StreamDirectory(Obj.Streams.size());
   Obj.Header.StreamDirectoryRVA =
       File.allocateArray(makeArrayRef(StreamDirectory));
   Obj.Header.NumberOfStreams = StreamDirectory.size();
 
   for (auto &Stream : enumerate(Obj.Streams))
     StreamDirectory[Stream.index()] = layout(File, *Stream.value());
 
   File.writeTo(Out);
-  return 0;
+  return true;
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/WasmEmitter.cpp

 
 using namespace llvm;
 
 namespace {
 /// This parses a yaml stream that represents a Wasm object file.
 /// See docs/yaml2obj for the yaml scheema.
 class WasmWriter {
 public:
-  WasmWriter(WasmYAML::Object &Obj) : Obj(Obj) {}
-  int writeWasm(raw_ostream &OS);
+  WasmWriter(WasmYAML::Object &Obj, yaml::ErrorHandler EH)
+      : Obj(Obj), ErrHandler(EH) {}
+  bool writeWasm(raw_ostream &OS);
 
 private:
-  int writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
+  void writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
                          uint32_t SectionIndex);
 
-  int writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::GlobalSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::EventSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::ExportSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::StartSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::ElemSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::DataCountSection &Section);
+  void writeInitExpr(raw_ostream &OS, const wasm::WasmInitExpr &InitExpr);
+
+  void writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::GlobalSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::EventSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::ExportSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::StartSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::ElemSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::DataCountSection &Section);
 
   // Custom section types
-  int writeSectionContent(raw_ostream &OS, WasmYAML::DylinkSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section);
-  int writeSectionContent(raw_ostream &OS, WasmYAML::ProducersSection &Section);
-  int writeSectionContent(raw_ostream &OS,
+  void writeSectionContent(raw_ostream &OS, WasmYAML::DylinkSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::ProducersSection &Section);
+  void writeSectionContent(raw_ostream &OS,
                           WasmYAML::TargetFeaturesSection &Section);
   WasmYAML::Object &Obj;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedEvents = 0;
+
+  bool HasError = false;
+  yaml::ErrorHandler ErrHandler;
+  void reportError(const Twine &Msg);
 };
 
 class SubSectionWriter {
   raw_ostream &OS;
   std::string OutString;
   raw_string_ostream StringStream;
 
 public:

 static int writeLimits(const WasmYAML::Limits &Lim, raw_ostream &OS) {
   writeUint8(OS, Lim.Flags);
   encodeULEB128(Lim.Initial, OS);
   if (Lim.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     encodeULEB128(Lim.Maximum, OS);
   return 0;
 }
 
-static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
+void WasmWriter::reportError(const Twine &Msg) {
+  ErrHandler(Msg);
+  HasError = true;
+}
+
+void WasmWriter::writeInitExpr(raw_ostream &OS, const wasm::WasmInitExpr &InitExpr) {
   writeUint8(OS, InitExpr.Opcode);
   switch (InitExpr.Opcode) {
   case wasm::WASM_OPCODE_I32_CONST:
     encodeSLEB128(InitExpr.Value.Int32, OS);
     break;
   case wasm::WASM_OPCODE_I64_CONST:
     encodeSLEB128(InitExpr.Value.Int64, OS);
     break;
   case wasm::WASM_OPCODE_F32_CONST:
     writeUint32(OS, InitExpr.Value.Float32);
     break;
   case wasm::WASM_OPCODE_F64_CONST:
     writeUint64(OS, InitExpr.Value.Float64);
     break;
   case wasm::WASM_OPCODE_GLOBAL_GET:
     encodeULEB128(InitExpr.Value.Global, OS);
     break;
   default:
-    errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode << "\n";
-    return 1;
+    reportError("unknown opcode in init_expr: " + Twine(InitExpr.Opcode));
+    return;
   }
   writeUint8(OS, wasm::WASM_OPCODE_END);
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::DylinkSection &Section) {
   writeStringRef(Section.Name, OS);
   encodeULEB128(Section.MemorySize, OS);
   encodeULEB128(Section.MemoryAlignment, OS);
   encodeULEB128(Section.TableSize, OS);
   encodeULEB128(Section.TableAlignment, OS);
   encodeULEB128(Section.Needed.size(), OS);
-  for (StringRef Needed : Section.Needed) {
+  for (StringRef Needed : Section.Needed)
     writeStringRef(Needed, OS);
-  }
-  return 0;
-}
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::LinkingSection &Section) {
   writeStringRef(Section.Name, OS);
   encodeULEB128(Section.Version, OS);
 
   SubSectionWriter SubSection(OS);
 
   // SYMBOL_TABLE subsection
   if (Section.SymbolTable.size()) {
     writeUint8(OS, wasm::WASM_SYMBOL_TABLE);
for (const auto &C : Section.Comdats) {
       encodeULEB128(C.Entries.size(), SubSection.getStream());
       for (const WasmYAML::ComdatEntry &Entry : C.Entries) {
         writeUint8(SubSection.getStream(), Entry.Kind);
         encodeULEB128(Entry.Index, SubSection.getStream());
       }
     }
     SubSection.done();
   }
-
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::NameSection &Section) {
   writeStringRef(Section.Name, OS);
   if (Section.FunctionNames.size()) {
     writeUint8(OS, wasm::WASM_NAMES_FUNCTION);
 
     SubSectionWriter SubSection(OS);
 
     encodeULEB128(Section.FunctionNames.size(), SubSection.getStream());
     for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
       encodeULEB128(NameEntry.Index, SubSection.getStream());
       writeStringRef(NameEntry.Name, SubSection.getStream());
     }
 
     SubSection.done();
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::ProducersSection &Section) {
   writeStringRef(Section.Name, OS);
   int Fields = int(!Section.Languages.empty()) + int(!Section.Tools.empty()) +
                int(!Section.SDKs.empty());
   if (Fields == 0)
-    return 0;
+    return;
   encodeULEB128(Fields, OS);
   for (auto &Field : {std::make_pair(StringRef("language"), &Section.Languages),
                       std::make_pair(StringRef("processed-by"), &Section.Tools),
                       std::make_pair(StringRef("sdk"), &Section.SDKs)}) {
     if (Field.second->empty())
       continue;
     writeStringRef(Field.first, OS);
     encodeULEB128(Field.second->size(), OS);
     for (auto &Entry : *Field.second) {
       writeStringRef(Entry.Name, OS);
       writeStringRef(Entry.Version, OS);
     }
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::TargetFeaturesSection &Section) {
   writeStringRef(Section.Name, OS);
   encodeULEB128(Section.Features.size(), OS);
   for (auto &E : Section.Features) {
     writeUint8(OS, E.Prefix);
     writeStringRef(E.Name, OS);
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::CustomSection &Section) {
   if (auto S = dyn_cast<WasmYAML::DylinkSection>(&Section)) {
-    if (auto Err = writeSectionContent(OS, *S))
-      return Err;
+    writeSectionContent(OS, *S);
   } else if (auto S = dyn_cast<WasmYAML::NameSection>(&Section)) {
-    if (auto Err = writeSectionContent(OS, *S))
-      return Err;
+    writeSectionContent(OS, *S);
   } else if (auto S = dyn_cast<WasmYAML::LinkingSection>(&Section)) {
-    if (auto Err = writeSectionContent(OS, *S))
-      return Err;
+    writeSectionContent(OS, *S);
   } else if (auto S = dyn_cast<WasmYAML::ProducersSection>(&Section)) {
-    if (auto Err = writeSectionContent(OS, *S))
-      return Err;
+    writeSectionContent(OS, *S);
   } else if (auto S = dyn_cast<WasmYAML::TargetFeaturesSection>(&Section)) {
-    if (auto Err = writeSectionContent(OS, *S))
-      return Err;
+    writeSectionContent(OS, *S);
   } else {
     writeStringRef(Section.Name, OS);
     Section.Payload.writeAsBinary(OS);
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::TypeSection &Section) {
   encodeULEB128(Section.Signatures.size(), OS);
   uint32_t ExpectedIndex = 0;
   for (const WasmYAML::Signature &Sig : Section.Signatures) {
     if (Sig.Index != ExpectedIndex) {
-      errs() << "Unexpected type index: " << Sig.Index << "\n";
-      return 1;
+      reportError("unexpected type index: " + Twine(Sig.Index));
+      return;
     }
     ++ExpectedIndex;
     writeUint8(OS, Sig.Form);
     encodeULEB128(Sig.ParamTypes.size(), OS);
     for (auto ParamType : Sig.ParamTypes)
       writeUint8(OS, ParamType);
     if (Sig.ReturnType == wasm::WASM_TYPE_NORESULT) {
       encodeULEB128(0, OS);
     } else {
       encodeULEB128(1, OS);
       writeUint8(OS, Sig.ReturnType);
     }
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ImportSection &Section) {
   encodeULEB128(Section.Imports.size(), OS);
   for (const WasmYAML::Import &Import : Section.Imports) {
     writeStringRef(Import.Module, OS);
     writeStringRef(Import.Field, OS);
     writeUint8(OS, Import.Kind);
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
for (const WasmYAML::Import &Import : Section.Imports) {
     case wasm::WASM_EXTERNAL_MEMORY:
       writeLimits(Import.Memory, OS);
       break;
     case wasm::WASM_EXTERNAL_TABLE:
       writeUint8(OS, Import.TableImport.ElemType);
       writeLimits(Import.TableImport.TableLimits, OS);
       break;
     default:
-      errs() << "Unknown import type: " << Import.Kind << "\n";
-      return 1;
+      reportError("unknown import type: " +Twine(Import.Kind));
+      return;
     }
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::FunctionSection &Section) {
   encodeULEB128(Section.FunctionTypes.size(), OS);
-  for (uint32_t FuncType : Section.FunctionTypes) {
+  for (uint32_t FuncType : Section.FunctionTypes)
     encodeULEB128(FuncType, OS);
-  }
-  return 0;
-}
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ExportSection &Section) {
   encodeULEB128(Section.Exports.size(), OS);
   for (const WasmYAML::Export &Export : Section.Exports) {
     writeStringRef(Export.Name, OS);
     writeUint8(OS, Export.Kind);
     encodeULEB128(Export.Index, OS);
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::StartSection &Section) {
   encodeULEB128(Section.StartFunction, OS);
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::TableSection &Section) {
   encodeULEB128(Section.Tables.size(), OS);
   for (auto &Table : Section.Tables) {
     writeUint8(OS, Table.ElemType);
     writeLimits(Table.TableLimits, OS);
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::MemorySection &Section) {
   encodeULEB128(Section.Memories.size(), OS);
-  for (const WasmYAML::Limits &Mem : Section.Memories) {
+  for (const WasmYAML::Limits &Mem : Section.Memories)
     writeLimits(Mem, OS);
-  }
-  return 0;
-}
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::GlobalSection &Section) {
   encodeULEB128(Section.Globals.size(), OS);
   uint32_t ExpectedIndex = NumImportedGlobals;
   for (auto &Global : Section.Globals) {
     if (Global.Index != ExpectedIndex) {
-      errs() << "Unexpected global index: " << Global.Index << "\n";
-      return 1;
+      reportError("unexpected global index: " + Twine(Global.Index));
+      return;
     }
     ++ExpectedIndex;
     writeUint8(OS, Global.Type);
     writeUint8(OS, Global.Mutable);
-    writeInitExpr(Global.InitExpr, OS);
+    writeInitExpr(OS, Global.InitExpr);
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::EventSection &Section) {
   encodeULEB128(Section.Events.size(), OS);
   uint32_t ExpectedIndex = NumImportedEvents;
   for (auto &Event : Section.Events) {
     if (Event.Index != ExpectedIndex) {
-      errs() << "Unexpected event index: " << Event.Index << "\n";
-      return 1;
+      reportError("unexpected event index: " + Twine(Event.Index));
+      return;
     }
     ++ExpectedIndex;
     encodeULEB128(Event.Attribute, OS);
     encodeULEB128(Event.SigIndex, OS);
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::ElemSection &Section) {
   encodeULEB128(Section.Segments.size(), OS);
   for (auto &Segment : Section.Segments) {
     encodeULEB128(Segment.TableIndex, OS);
-    writeInitExpr(Segment.Offset, OS);
+    writeInitExpr(OS, Segment.Offset);
 
     encodeULEB128(Segment.Functions.size(), OS);
-    for (auto &Function : Segment.Functions) {
+    for (auto &Function : Segment.Functions)
       encodeULEB128(Function, OS);
-    }
-  }
-  return 0;
-}
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::CodeSection &Section) {
   encodeULEB128(Section.Functions.size(), OS);
   uint32_t ExpectedIndex = NumImportedFunctions;
   for (auto &Func : Section.Functions) {
     std::string OutString;
     raw_string_ostream StringStream(OutString);
     if (Func.Index != ExpectedIndex) {
-      errs() << "Unexpected function index: " << Func.Index << "\n";
-      return 1;
+      reportError("unexpected function index: " + Twine(Func.Index));
+      return;
     }
     ++ExpectedIndex;
 
     encodeULEB128(Func.Locals.size(), StringStream);
     for (auto &LocalDecl : Func.Locals) {
       encodeULEB128(LocalDecl.Count, StringStream);
       writeUint8(StringStream, LocalDecl.Type);
     }
 
     Func.Body.writeAsBinary(StringStream);
 
     // Write the section size followed by the content
     StringStream.flush();
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::DataSection &Section) {
   encodeULEB128(Section.Segments.size(), OS);
   for (auto &Segment : Section.Segments) {
     encodeULEB128(Segment.InitFlags, OS);
     if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
       encodeULEB128(Segment.MemoryIndex, OS);
     if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0)
-      writeInitExpr(Segment.Offset, OS);
+      writeInitExpr(OS, Segment.Offset);
     encodeULEB128(Segment.Content.binary_size(), OS);
     Segment.Content.writeAsBinary(OS);
   }
-  return 0;
 }
 
-int WasmWriter::writeSectionContent(raw_ostream &OS,
+void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::DataCountSection &Section) {
   encodeULEB128(Section.Count, OS);
-  return 0;
 }
 
-int WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
+void WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
                                   uint32_t SectionIndex) {
   switch (Sec.Type) {
   case wasm::WASM_SEC_CODE:
     writeStringRef("reloc.CODE", OS);
     break;
   case wasm::WASM_SEC_DATA:
     writeStringRef("reloc.DATA", OS);
     break;
   case wasm::WASM_SEC_CUSTOM: {
     auto CustomSection = dyn_cast<WasmYAML::CustomSection>(&Sec);
     writeStringRef(("reloc." + CustomSection->Name).str(), OS);
     break;
   }
   default:
     llvm_unreachable("not yet implemented");
-    return 1;
   }
 
   encodeULEB128(SectionIndex, OS);
   encodeULEB128(Sec.Relocations.size(), OS);
 
   for (auto Reloc : Sec.Relocations) {
     writeUint8(OS, Reloc.Type);
     encodeULEB128(Reloc.Offset, OS);
     encodeULEB128(Reloc.Index, OS);
     switch (Reloc.Type) {
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
     case wasm::R_WASM_SECTION_OFFSET_I32:
       encodeULEB128(Reloc.Addend, OS);
     }
   }
-  return 0;
 }
 
-int WasmWriter::writeWasm(raw_ostream &OS) {
+bool WasmWriter::writeWasm(raw_ostream &OS) {
   // Write headers
   OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
   writeUint32(OS, Obj.Header.Version);
 
   // Write each section
   llvm::object::WasmSectionOrderChecker Checker;
   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     StringRef SecName = "";
     if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get()))
       SecName = S->Name;
     if (!Checker.isValidSectionOrder(Sec->Type, SecName)) {
-      errs() << "Out of order section type: " << Sec->Type << "\n";
-      return 1;
+      reportError("out of order section type: " + Twine(Sec->Type));
+      return false;
     }
     encodeULEB128(Sec->Type, OS);
     std::string OutString;
     raw_string_ostream StringStream(OutString);
-    if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::ImportSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::FunctionSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::TableSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::MemorySection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::GlobalSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::EventSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::ExportSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::StartSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::ElemSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::CodeSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::DataSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else if (auto S = dyn_cast<WasmYAML::DataCountSection>(Sec.get())) {
-      if (auto Err = writeSectionContent(StringStream, *S))
-        return Err;
-    } else {
-      errs() << "Unknown section type: " << Sec->Type << "\n";
-      return 1;
-    }
+    if (auto S = dyn_cast<WasmYAML::CustomSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::TypeSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::ImportSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::FunctionSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::TableSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::MemorySection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::GlobalSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::EventSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::ExportSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::StartSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::ElemSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::CodeSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::DataSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else if (auto S = dyn_cast<WasmYAML::DataCountSection>(Sec.get()))
+      writeSectionContent(StringStream, *S);
+    else
+      reportError("unknown section type: " + Twine(Sec->Type));
+
+    if (HasError)
+      return false;
+
     StringStream.flush();
 
     // Write the section size followed by the content
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
   }
 
   // write reloc sections for any section that have relocations
for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     raw_string_ostream StringStream(OutString);
     writeRelocSection(StringStream, *Sec, SectionIndex++);
     StringStream.flush();
 
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
   }
 
-  return 0;
+  return true;
 }
 
 namespace llvm {
 namespace yaml {
 
-int yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out) {
-  WasmWriter Writer(Doc);
-
+bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH) {
+  WasmWriter Writer(Doc, EH);
   return Writer.writeWasm(Out);
 }
 
 } // namespace yaml
 } // namespace llvm

lib/ObjectYAML/yaml2obj.cpp

 //===-- yaml2obj.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/Support/Errc.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 
 namespace llvm {
 namespace yaml {
 
-Error convertYAML(yaml::Input &YIn, raw_ostream &Out, unsigned DocNum) {
-  // TODO: make yaml2* functions return Error instead of int.
-  auto IntToErr = [](int Ret) -> Error {
-    if (Ret)
-      return createStringError(errc::invalid_argument, "yaml2obj failed");
-    return Error::success();
-  };
+static void defaultErrorHandler(const Twine &Msg) {
+  WithColor::error() << Msg << "\n";
+}
 
+bool convertYAML(yaml::Input &YIn, raw_ostream &Out, ErrorHandler ErrHandler,
+                 unsigned DocNum) {
   unsigned CurDocNum = 0;
   do {
-    if (++CurDocNum == DocNum) {
-      yaml::YamlObjectFile Doc;
-      YIn >> Doc;
-      if (std::error_code EC = YIn.error())
-        return createStringError(EC, "Failed to parse YAML input!");
-      if (Doc.Elf)
-        return IntToErr(yaml2elf(*Doc.Elf, Out));
-      if (Doc.Coff)
-        return IntToErr(yaml2coff(*Doc.Coff, Out));
-      if (Doc.MachO || Doc.FatMachO)
-        return IntToErr(yaml2macho(Doc, Out));
-      if (Doc.Minidump)
-        return IntToErr(yaml2minidump(*Doc.Minidump, Out));
-      if (Doc.Wasm)
-        return IntToErr(yaml2wasm(*Doc.Wasm, Out));
-      return createStringError(errc::invalid_argument,
-                               "Unknown document type!");
-    }
+    if (++CurDocNum != DocNum)
+      continue;
+
+    if (std::error_code EC = YIn.error()) {
+      ErrHandler("failed to parse YAML input: " + EC.message());
+      return false;
+    }
+
+      return yaml2elf(*Doc.Elf, Out, ErrHandler);
+      return yaml2coff(*Doc.Coff, Out, ErrHandler);
+      return yaml2macho(Doc, Out, ErrHandler);
+      return yaml2minidump(*Doc.Minidump, Out, ErrHandler);
+      return yaml2wasm(*Doc.Wasm, Out, ErrHandler);
+
+    ErrHandler("unknown document type");
+    return false;
+
   } while (YIn.nextDocument());
 
-  return createStringError(errc::invalid_argument,
-                           "Cannot find the %u%s document", DocNum,
-                           getOrdinalSuffix(DocNum).data());
+  ErrHandler("cannot find the " + Twine(DocNum) +
+             getOrdinalSuffix(DocNum).data() + " document");
+  return false;
 }
 
-Expected<std::unique_ptr<object::ObjectFile>>
-yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml) {
+std::unique_ptr<object::ObjectFile>
+yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml,
+                ErrorHandler ErrHandler) {
   Storage.clear();
   raw_svector_ostream OS(Storage);
 
   yaml::Input YIn(Yaml);
-  if (Error E = convertYAML(YIn, OS))
-    return std::move(E);
+  if (!convertYAML(YIn, OS, ErrHandler))
+    return {};
 
-  return object::ObjectFile::createObjectFile(
+  Expected<std::unique_ptr<object::ObjectFile>> ObjOrErr =
+      object::ObjectFile::createObjectFile(
           MemoryBufferRef(OS.str(), "YamlObject"));
+  if (ObjOrErr)
+    return std::move(*ObjOrErr);
+
+  ErrHandler(toString(ObjOrErr.takeError()));
+  return {};
 }
 
 } // namespace yaml
 } // namespace llvm

test/ObjectYAML/wasm/invalid_section_order.yaml

 # RUN: not yaml2obj %s -o /dev/null 2>&1 | FileCheck %s
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            TYPE
     Signatures:
       - Index:           0
         ReturnType:      NORESULT
         ParamTypes:      []
   - Type:            CODE
     Functions:
       - Index:           0
         Locals:          []
         Body:            0B
-  # CHECK: Out of order section type: 3
+  # CHECK: yaml2obj: error: out of order section type: 3
   - Type:            FUNCTION
     FunctionTypes:   [ 0 ]
 ...

test/tools/yaml2obj/coff-invalid-alignment.test

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
-## CHECK: Section alignment is too large
+## CHECK: error: section alignment is too large
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: []
 sections:
   - Name:            '.text'
     Characteristics: []
     SectionData:     00
     Alignment:       16384
 symbols:

test/tools/yaml2obj/dynsymtab-implicit-sections-size-content.yaml

 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
 
 ## Specifying both `Size` and symbols at the same time is not allowed for .dynsym.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --implicit-check-not=error --check-prefix=CASE2
 
-# CASE2: error: cannot specify both `Size` and `DynamicSymbols` for symbol table section '.dynsym'
-# CASE2: error: yaml2obj failed
+# CASE2: yaml2obj: error: cannot specify both `Size` and `DynamicSymbols` for symbol table section '.dynsym'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
     Size: 0x100
   - Name: .dynsym2
     Type: SHT_DYNSYM
     Size: 0x100
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
 
 ## Specifying both `Content` and symbols at the same time is not allowed for .dynsym.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --implicit-check-not=error --check-prefix=CASE3
 
-# CASE3: error: cannot specify both `Content` and `DynamicSymbols` for symbol table section '.dynsym'
-# CASE3: error: yaml2obj failed
+# CASE3: yaml2obj: error: cannot specify both `Content` and `DynamicSymbols` for symbol table section '.dynsym'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:

test/tools/yaml2obj/empty-or-invalid-doc.yaml

 # RUN: echo "" | not yaml2obj 2>&1 | FileCheck %s
 # RUN: echo -n "" | not yaml2obj 2>&1 | FileCheck %s
 # RUN: echo " " | not yaml2obj 2>&1 | FileCheck %s
 # RUN: echo "  " | not yaml2obj 2>&1 | FileCheck %s
-# CHECK: error: Unknown document type!
+# CHECK: yaml2obj: error: unknown document type
 
 # RUN: echo -e -n "\xff" | not yaml2obj 2>&1 | FileCheck %s --check-prefix=INVALID
-# INVALID: error: Failed to parse YAML input!
+# INVALID: yaml2obj: error: failed to parse YAML input

test/tools/yaml2obj/invalid-docnum.test

 ## Test that an error is reported when a docnum is specified, which is
 ## greater than the number of YAML inputs in the file.
 
 # RUN: not yaml2obj %s --docnum=3 2>&1 | FileCheck %s
-# CHECK: error: Cannot find the 3rd document
+# CHECK: yaml2obj: error: cannot find the 3rd document
 
 # RUN: not yaml2obj %s --docnum=76768677 2>&1 | FileCheck %s --check-prefix=TWO
-# TWO: error: Cannot find the 76768677th document
+# TWO: yaml2obj: error: cannot find the 76768677th document
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64

test/tools/yaml2obj/invalid_output_file.test

 # RUN: not yaml2obj -o %p/path/does/not/exist 2>&1 | FileCheck %s
 
 # Don't check the OS-dependent message "No such file or directory".
-# CHECK: yaml2obj: Error opening '{{.*}}/path/does/not/exist': {{.*}}
+# CHECK: yaml2obj: error: can't open '{{.*}}/path/does/not/exist': {{.*}}

test/tools/yaml2obj/missing_document_tag.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 ---
 DummyData:
   foo:           0
 ...
 
 # CHECK: YAML:4:1: error: YAML Object File missing document type tag!
-# CHECK: error: Failed to parse YAML input!
+# CHECK: error: failed to parse YAML input

test/tools/yaml2obj/multi-doc.test

 # RUN:   | llvm-readobj --symbols - | FileCheck -check-prefix=DOC4 %s
 # RUN: not yaml2obj -docnum=5 %s 2>&1 \
 # RUN:   | FileCheck -check-prefix=DOC5 %s
 
 # DOC1: Name: _sym1
 # DOC2: Name: _sym2
 # DOC3: Name: _sym3
 # DOC4: Name: _sym4
-# DOC5: error: Cannot find the 5th document
+# DOC5: error: cannot find the 5th document
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS32
   Data: ELFDATA2LSB
   Type: ET_REL
   Machine: EM_MIPS
   Flags: [EF_MIPS_CPIC]

test/tools/yaml2obj/reloc-sec-info.yaml

- Name:            .rela.text
     Relocations:
 
 ## Check we report an error when a relocation section references an unknown section via its Info field.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --implicit-check-not=error --check-prefix=ERR
 
 # ERR: error: unknown section referenced: '.unknown1' by YAML section '.foo'
 # ERR: error: unknown section referenced: '.unknown2' by YAML section '.bar'
-# ERR: error: yaml2obj failed
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

test/tools/yaml2obj/section-size-content.yaml

- Name: .data
     Type: SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Content: 0000000000000000
     Size: 2
 
 # ERR2:      error: Section size must be greater than or equal to the content size
 # ERR2-NEXT: - Name: .data
 # ERR2-NEXT:   ^
-# ERR2-NEXT: error: Failed to parse YAML input!
+# ERR2-NEXT: error: failed to parse YAML input

tools/llvm-ifs/llvm-ifs.cpp

int writeElfStub(const llvm::Triple &T, const std::set<IFSSymbol> &Symbols,
   LLVM_DEBUG({
     if (ForceFormat == "ELFOBJYAML") {
       Out << YamlStr;
       return 0;
     }
   });
 
   yaml::Input YIn(YamlStr);
-  if (Error E = convertYAML(YIn, Out)) {
-    logAllUnhandledErrors(std::move(E), WithColor::error(errs(), "llvm-ifs"));
-    return 1;
-  }
-
-  return 0;
+  auto ErrHandler = [](const Twine &Msg) {
+    WithColor::error(errs(), "llvm-ifs") << Msg << "\n";
+  };
+  return convertYAML(YIn, Out, ErrHandler) ? 0 : 1;
 }
 
 int writeIfso(const IFSStub &Stub, bool IsWriteIfs, raw_ostream &Out) {
   if (IsWriteIfs) {
     yaml::Output YamlOut(Out, NULL, /*WrapColumn =*/0);
     YamlOut << const_cast<IFSStub &>(Stub);
     return 0;
   }

tools/yaml2obj/yaml2obj.cpp

 
 cl::opt<unsigned>
 DocNum("docnum", cl::init(1),
        cl::desc("Read specified document from input (default = 1)"));
 
 static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"),
                                            cl::value_desc("filename"));
 
-LLVM_ATTRIBUTE_NORETURN static void error(Twine Message) {
-  errs() << Message << "\n";
-  exit(1);
-}
-
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv);
 
   if (OutputFilename.empty())
     OutputFilename = "-";
 
+  auto ErrHandler = [](const Twine &Msg) {
+    WithColor::error(errs(), "yaml2obj") << Msg << "\n";
+  };
+
   std::error_code EC;
   std::unique_ptr<ToolOutputFile> Out(
       new ToolOutputFile(OutputFilename, EC, sys::fs::OF_None));
-  if (EC)
-    error("yaml2obj: Error opening '" + OutputFilename + "': " + EC.message());
+  if (EC) {
+    ErrHandler("can't open '" + OutputFilename + "': " + EC.message());
+    return 1;
+  }
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
       MemoryBuffer::getFileOrSTDIN(Input);
   if (!Buf)
     return 1;
 
   yaml::Input YIn(Buf.get()->getBuffer());
-  if (Error E = convertYAML(YIn, Out->os(), DocNum)) {
-    logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
+  if (!convertYAML(YIn, Out->os(), ErrHandler, DocNum))
     return 1;
-  }
 
   Out->keep();
   Out->os().flush();
   return 0;
 }

unittests/ObjectYAML/MinidumpYAMLTest.cpp

 using namespace llvm;
 using namespace llvm::minidump;
 
 static Expected<std::unique_ptr<object::MinidumpFile>>
 toBinary(SmallVectorImpl<char> &Storage, StringRef Yaml) {
   Storage.clear();
   raw_svector_ostream OS(Storage);
   yaml::Input YIn(Yaml);
-  if (Error E = yaml::convertYAML(YIn, OS))
-    return std::move(E);
+  if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
+    return createStringError(std::errc::invalid_argument,
+                             "unable to convert YAML");
 
   return object::MinidumpFile::create(MemoryBufferRef(OS.str(), "Binary"));
 }
 
 TEST(MinidumpYAML, Basic) {
   SmallString<0> Storage;
   auto ExpectedFile = toBinary(Storage, R"(
 --- !minidump

unittests/ObjectYAML/YAML2ObjTest.cpp

 //===- YAML2ObjTest.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/YAMLTraits.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace object;
 using namespace yaml;
 
 TEST(yaml2ObjectFile, ELF) {
+  bool ErrorReported = false;
+  auto ErrHandler = [&](const Twine &Msg) { ErrorReported = true; };
+
   SmallString<0> Storage;
-  Expected<std::unique_ptr<ObjectFile>> ErrOrObj = yaml2ObjectFile(Storage, R"(
+  std::unique_ptr<ObjectFile> Obj = yaml2ObjectFile(Storage, R"(
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
-  Machine:  EM_X86_64)");
+  Machine:  EM_X86_64)", ErrHandler);
 
-  ASSERT_THAT_EXPECTED(ErrOrObj, Succeeded());
+  ASSERT_FALSE(ErrorReported);
+  ASSERT_TRUE(Obj);
+  ASSERT_TRUE(Obj->isELF());
+  ASSERT_TRUE(Obj->isRelocatableObject());
+}
 
-  std::unique_ptr<ObjectFile> ObjFile = std::move(ErrOrObj.get());
+TEST(yaml2ObjectFile, Errors) {
+  std::vector<std::string> Errors;
+  auto ErrHandler = [&](const Twine &Msg) {
+    Errors.push_back("ObjectYAML: " + Msg.str());
+  };
 
-  ASSERT_TRUE(ObjFile->isELF());
-  ASSERT_TRUE(ObjFile->isRelocatableObject());
-}
+  SmallString<0> Storage;
+  StringRef Yaml = R"(
+--- !ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+Symbols:
+  - Name: foo
+  - Name: foo
+  - Name: foo
+)";
+
+  // 1. Test the yaml2ObjectFile().
+
+  std::unique_ptr<ObjectFile> Obj = yaml2ObjectFile(Storage, Yaml, ErrHandler);
+
+  ASSERT_FALSE(Obj);
+  ASSERT_TRUE(Errors.size() == 2);
+  ASSERT_TRUE(Errors[0] == "ObjectYAML: repeated symbol name: 'foo'");
+  ASSERT_TRUE(Errors[1] == Errors[0]);
+
+  // 2. Test the convertYAML(). 
+
+  Errors.clear();
+  Storage.clear();
+  raw_svector_ostream OS(Storage);
+
+  yaml::Input YIn(Yaml);
+  bool Res = convertYAML(YIn, OS, ErrHandler);
+  ASSERT_FALSE(Res);
+  ASSERT_TRUE(Errors.size() == 2);
+  ASSERT_TRUE(Errors[0] == "ObjectYAML: repeated symbol name: 'foo'");
+  ASSERT_TRUE(Errors[1] == Errors[0]);
+}
 No newline at end of file