[yaml2obj] Move core yaml2obj code into lib and include for use in unit tests

[abrachet]

Added StringRef include

[labath]

Thanks for taking this on. I look forward to being able to use this in lldb tests.

I'm not an owner here, but the main question I have is about the library-readiness of the code you're moving. I see it's doing things like spewing errors to stderr and even calling exit(), neither of which is a very nice thing to do for a library (even if it's just a "test" library). Do you have any plans for addressing that?

llvm/unittests/ObjectYAML/yaml2ObjectFileTest.cpp

30 ↗

(On Diff #211665)

nit: ASSERT_THAT_EXPECTED (from Testing/Support/Error.h) will print the actual error message if this ever fails (instead of just a useless "false is not true").

[grimar]

Generally looks OK to me. Comments/questions are inlined.

llvm/lib/ObjectYAML/yaml2obj.cpp

32

yaml2obj was a tool name. Should it still be printed?

Also seems it should not refer to file anymore, should it be "failed to parte YAML input"?
I guess that worth a unit test probably.

[MaskRay]

llvm/lib/ObjectYAML/WasmEmitter.cpp

658–661

It is probably time to wrap these things in

namespace llvm {
namespace yaml {
...
}
}

[jhenderson]

In D65255#1600507, @labath wrote:

Thanks for taking this on. I look forward to being able to use this in lldb tests.

I'm not an owner here, but the main question I have is about the library-readiness of the code you're moving. I see it's doing things like spewing errors to stderr and even calling exit(), neither of which is a very nice thing to do for a library (even if it's just a "test" library). Do you have any plans for addressing that?

I suggested to Alex offline that he not try to do any more than the bare minimum to get this moved over. Certainly more work needs doing to it, but I think that can be done at a later point rather than upfront when moving it, given how useful it will be to have when working on the libObject code if nothing else.

llvm/include/llvm/ObjectYAML/yaml2obj.h

53

Let's have this return an llvm::Error. I shouldn't massively increase the complexity of this code.

llvm/lib/ObjectYAML/CMakeLists.txt

1

Looks like this CMake is missing any reference to the include files, which means they won't get auto-magically added to things like Visual Studio's projects. If you take a look at libObject's CMakeLists.txt, you'll find an example of what to do.

22–27

My instinct is that we should rename these files to match the naming style of other files in this library. Open to other suggestions though.

llvm/lib/ObjectYAML/yaml2obj.cpp

20–23

We should avoid functions like this in the new library code. Better would be something that returned llvm::Error. In practice, you should probably just call createStringError at all its call sites and pass the resultant Error up the stack.

llvm/unittests/ObjectYAML/CMakeLists.txt

10

Looks like filenames usually start with an upper-case letter. Also, the filenames usually reflect the names of the file they are testing, in this case yaml2obj.cpp, so let's call this YAML2ObjTest.cpp.

[MaskRay]

In D65255#1601122, @jhenderson wrote:

In D65255#1600507, @labath wrote:

Thanks for taking this on. I look forward to being able to use this in lldb tests.

I'm not an owner here, but the main question I have is about the library-readiness of the code you're moving. I see it's doing things like spewing errors to stderr and even calling exit(), neither of which is a very nice thing to do for a library (even if it's just a "test" library). Do you have any plans for addressing that?

I suggested to Alex offline that he not try to do any more than the bare minimum to get this moved over. Certainly more work needs doing to it, but I think that can be done at a later point rather than upfront when moving it, given how useful it will be to have when working on the libObject code if nothing else.

I agree. It'd be useful if @labath can elaborate which parts he intends to use in lldb. This will help decide how much of yaml2obj should be moved to lib/ObjectYAML.

llvm/tools/yaml2obj/yaml2obj.cpp

45

There is probably not much we gain by moving this part to lib/ObjectYAML.

[abrachet]

Changed return of convertYAML to Error. Changed name of files from yaml2X to XEmitter. Wrapped unexported functions in anonymous namespace. clang-format.

[abrachet]

git clang-format does not understand moved files it turns out, so it formatted things that I didn't touch. I figure if this is going to happen it might as well be now, though. I can change this back though.

llvm/lib/ObjectYAML/CMakeLists.txt

1

CMake doesn't fail when generating files so I haven't done anything horribly wrong. I assume this works but I don't know how to test if it did.

llvm/lib/ObjectYAML/WasmEmitter.cpp

658–661

I did this in all the files. Also I wrapped things in an anonymous namespace, is this ok?

llvm/tools/yaml2obj/yaml2obj.cpp

45

I think its more convenient to not have to specify the file type. I wonder what others have to say.

[abrachet]

llvm/unittests/ObjectYAML/yaml2ObjectFileTest.cpp

30 ↗

(On Diff #211665)

Thanks! I've been doing this a lot great to know about this better way!

[labath]

In D65255#1602049, @MaskRay wrote:

In D65255#1601122, @jhenderson wrote:

I suggested to Alex offline that he not try to do any more than the bare minimum to get this moved over. Certainly more work needs doing to it, but I think that can be done at a later point rather than upfront when moving it, given how useful it will be to have when working on the libObject code if nothing else.

I agree. It'd be useful if @labath can elaborate which parts he intends to use in lldb. This will help decide how much of yaml2obj should be moved to lib/ObjectYAML.

I'd like have a function which takes a (yaml) string, and get raw bytes in return. So, that would be slightly less that what you're doing in the unit test here (as you're also re-parsing those bytes into an object file), but I am guessing you're going to need the re-parsing bits for the work you're doing anyway.

Also, due to how lldb's object parsers work, I'll need to save that stream of bytes into a file, but that is something that can be easily handled on the lldb side too.

As for object types, my main interest is ELF files, as we already have unit tests using those (by shelling out to yaml2obj). However, having COFF and MachO support would be nice too, and if it's available people might be inclined to use it. Minidump is interesting too, but I already have a mechanism for using that.

I don't know if that answers your question. If it doesn't, you'll have to ask me something more specific. :)

llvm/lib/ObjectYAML/WasmEmitter.cpp

658–661

llvm policy http://llvm.org/docs/CodingStandards.html#anonymous-namespaces is to keep the anonymous namespaces as small as possible, preferring the static keyword instead. So, in this case, that would mean only the class definitions need to be wrapped in namespace{}.

llvm/tools/yaml2obj/yaml2obj.cpp

45

I'm pretty ambivalent. On one hand, it's nice to have the same interface as the command line tool, but on the other, in the test you should always know the object type, so appending that to the function name does not hurt.

[jhenderson]

llvm/lib/ObjectYAML/CMakeLists.txt

1

I checked with equivalent code, and it did the job on my Windows machine.

llvm/lib/ObjectYAML/yaml2obj.cpp

21

Maybe mark this with TODO:

Rather than an empty string, let's at least report something like "yaml2obj failed".

23

You don't need the trailing return type, I'm pretty sure.

llvm/test/tools/yaml2obj/invalid-docnum.test

23

Nit: no new line at end of file.

[abrachet]

Addressed review comments.

[abrachet]

llvm/lib/ObjectYAML/yaml2obj.cpp

23

For the first time, this one actually needs it :) Error::success() returns an ErrorSuccess

llvm/tools/yaml2obj/yaml2obj.cpp

45

I think the alternative would be code used in the same way in every test which wants to use it. See D64281 for how it can be used in unit tests. That was the same pattern that @labath did here D59482. It's not just about explicitly stating the object file type, this also does error handling etc.

[jhenderson]

llvm/lib/ObjectYAML/COFFEmitter.cpp

36

This struct should be in the anonymous namespace.

llvm/lib/ObjectYAML/ELFEmitter.cpp

57–58

You're closing the anonymous namespace here, but start one again about 3 lines later. Merge them together.

llvm/lib/ObjectYAML/WasmEmitter.cpp

26

This class should be in the anonymous namespace.

llvm/test/tools/yaml2obj/invalid-docnum.test

2

This sentence is poor grammar. Probably something like "Test that an error is reported when a docnum is specified, which is greater than the number of YAML inputs in the file."

[abrachet]

Addressed review comments

[rupprecht]

In D65255#1602062, @abrachet wrote:

git clang-format does not understand moved files it turns out, so it formatted things that I didn't touch. I figure if this is going to happen it might as well be now, though. I can change this back though.

I think it's fine to clang format the whole thing (since git clang-format isn't smart enough), but ideally it'd be a separate patch that lands first, so that this just shows the changes required for moving directories

llvm/lib/ObjectYAML/CMakeLists.txt

1

This fails in a -DBUILD_SHARED_LIBS=On cmake build; I think you need to add a dep on MC here (or add set(LLVM_LINK_COMPONENTS MC))

FAILED: lib/libLLVMObjectYAML.so.10svn
...
ld.lld: error: undefined symbol: llvm::StringTableBuilder::StringTableBuilder(llvm::StringTableBuilder::Kind, unsigned int)                                                                                       
>>> referenced by ELFEmitter.cpp:104 (/usr/local/google/home/rupprecht/src/llvm-project/llvm/lib/ObjectYAML/ELFEmitter.cpp:104)                                                                                   
>>>               lib/ObjectYAML/CMakeFiles/LLVMObjectYAML.dir/ELFEmitter.cpp.o:(llvm::yaml::yaml2elf(llvm::ELFYAML::Object&, llvm::raw_ostream&))

[abrachet]

fixed link issue

[abrachet]

llvm/lib/ObjectYAML/CMakeLists.txt

1

I ended up having to add quite a few more libraries before it would link. Were you just getting the errors you showed here or more than this?

[rupprecht]

llvm/lib/ObjectYAML/CMakeLists.txt

1

Oh, sorry, this was the wrong suggestion -- the link libraries are controlled by the other build system, LLVMBuild.txt (see http://llvm.org/docs/LLVMBuild.html).
MC is the only one that needed to be added, but by setting LLVM_LINK_COMPONENTS, that appears to overwrite what's in LLVMBuild.txt, leading to even more link errors.

Can you undo the change here and add MC to LLVMBuild.txt?

[abrachet]

Fixed link error in LLVMBuild.txt not CMakeLists.txt

[labath]

llvm/lib/ObjectYAML/CMakeLists.txt

1

Would this mean that we can also remove some entries from LLVM_LINK_COMPONENTS for the yaml2obj tool itself, now that it does not reference some of these libraries directly?

[abrachet]

Removed unnecessary LLVM_LINK_COMPONENTS in yaml2obj

[abrachet]

llvm/lib/ObjectYAML/CMakeLists.txt

1

Thank you @rupprecht that worked :)

Oh yeah. Thanks @labath :)

[gribozavr]

Sorry, this patch broke tests: http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/15993, I reverted it in r368035.

[abrachet]

In D65255#1616820, @gribozavr wrote:

Sorry, this patch broke tests: http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/15993, I reverted it in r368035.

I fixed those here rG9eee4254796df1a34a0452fa91e8ce4e38b6a5bb. Could you re-land or do I need to do it?

[abrachet]

Fixed failing test cases

llvm/include/llvm/ObjectYAML/yaml2obj.h

 //===--- yaml2obj.h - -------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// Common declarations for yaml2obj
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TOOLS_YAML2OBJ_YAML2OBJ_H
 #define LLVM_TOOLS_YAML2OBJ_YAML2OBJ_H
 
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include <memory>
+
 namespace llvm {
 class raw_ostream;
+template <typename T> class SmallVectorImpl;
+template <typename T> class Expected;
+
+namespace object {
+class ObjectFile;
+}
 
 namespace COFFYAML {
 struct Object;
 }
 
 namespace ELFYAML {
 struct Object;
 }
 
 namespace MinidumpYAML {
 struct Object;
 }
 
 namespace WasmYAML {
 struct Object;
 }
 
 namespace yaml {
 class Input;
 struct YamlObjectFile;
-}
-}
 
-int yaml2coff(llvm::COFFYAML::Object &Doc, llvm::raw_ostream &Out);
-int yaml2elf(llvm::ELFYAML::Object &Doc, llvm::raw_ostream &Out);
-int yaml2macho(llvm::yaml::YamlObjectFile &Doc, llvm::raw_ostream &Out);
-int yaml2minidump(llvm::MinidumpYAML::Object &Doc, llvm::raw_ostream &Out);
-int yaml2wasm(llvm::WasmYAML::Object &Doc, llvm::raw_ostream &Out);
+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);
+
+Error convertYAML(Input &YIn, raw_ostream &Out, unsigned DocNum = 1);
+
+/// Convenience function for tests.
+Expected<std::unique_ptr<object::ObjectFile>>
+yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml);
+
+} // namespace yaml
+} // namespace llvm
 
 #endif

llvm/lib/ObjectYAML/CMakeLists.txt

 add_llvm_library(LLVMObjectYAML
   CodeViewYAMLDebugSections.cpp
   CodeViewYAMLSymbols.cpp
   CodeViewYAMLTypeHashing.cpp
   CodeViewYAMLTypes.cpp
+  COFFEmitter.cpp
   COFFYAML.cpp
   DWARFEmitter.cpp
   DWARFVisitor.cpp
   DWARFYAML.cpp
+  ELFEmitter.cpp
   ELFYAML.cpp
+  MachOEmitter.cpp
   MachOYAML.cpp
   ObjectYAML.cpp
+  MinidumpEmitter.cpp
   MinidumpYAML.cpp
+  WasmEmitter.cpp
   WasmYAML.cpp
   XCOFFYAML.cpp
   YAML.cpp
+  yaml2obj.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${LLVM_MAIN_INCLUDE_DIR}/llvm/ObjectYAML
   )

llvm/lib/ObjectYAML/COFFEmitter.cpp

 //===- yaml2coff - Convert YAML to a COFF object file ---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// The COFF component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "yaml2obj.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 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) {
     // 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 {
struct COFFParser {
   }
 
   unsigned getSymbolSize() const {
     return useBigObj() ? COFF::Symbol32Size : COFF::Symbol16Size;
   }
 
   bool parseSections() {
     for (std::vector<COFFYAML::Section>::iterator i = Obj.Sections.begin(),
-           e = Obj.Sections.end(); i != e; ++i) {
+                                                  e = Obj.Sections.end();
+         i != e; ++i) {
       COFFYAML::Section &Sec = *i;
 
       // If the name is less than 8 bytes, store it in place, otherwise
       // store it in the string table.
       StringRef Name = Sec.Name;
 
       if (Name.size() <= COFF::NameSize) {
         std::copy(Name.begin(), Name.end(), Sec.Header.Name);
for (std::vector<COFFYAML::Section>::iterator i = Obj.Sections.begin(),
         Sec.Header.Characteristics |= (Log2_32(Sec.Alignment) + 1) << 20;
       }
     }
     return true;
   }
 
   bool parseSymbols() {
     for (std::vector<COFFYAML::Symbol>::iterator i = Obj.Symbols.begin(),
-           e = Obj.Symbols.end(); i != e; ++i) {
+                                                 e = Obj.Symbols.end();
+         i != e; ++i) {
       COFFYAML::Symbol &Sym = *i;
 
       // If the name is less than 8 bytes, store it in place, otherwise
       // store it in the string table.
       StringRef Name = Sym.Name;
       if (Name.size() <= COFF::NameSize) {
         std::copy(Name.begin(), Name.end(), Sym.Header.Name);
       } else {
         // Add string to the string table and format the index for output.
         unsigned Index = getStringIndex(Name);
-        *reinterpret_cast<support::aligned_ulittle32_t*>(
-            Sym.Header.Name + 4) = Index;
+        *reinterpret_cast<support::aligned_ulittle32_t *>(Sym.Header.Name + 4) =
+            Index;
       }
 
       Sym.Header.Type = Sym.SimpleType;
       Sym.Header.Type |= Sym.ComplexType << COFF::SCT_COMPLEX_TYPE_SHIFT;
     }
     return true;
   }
 
struct COFFParser {
   codeview::StringsAndChecksums StringsAndChecksums;
   BumpPtrAllocator Allocator;
   StringMap<unsigned> StringTableMap;
   std::string StringTable;
   uint32_t SectionTableStart;
   uint32_t SectionTableSize;
 };
 
+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 layoutOptionalHeader(COFFParser &CP) {
   if (!CP.isPE())
     return true;
   unsigned PEHeaderSize = CP.is64Bit() ? sizeof(object::pe32plus_header)
                                        : sizeof(object::pe32_header);
   CP.Obj.Header.SizeOfOptionalHeader =
       PEHeaderSize +
       sizeof(object::data_directory) * (COFF::NUM_DATA_DIRECTORIES + 1);
   return true;
 }
 
-namespace {
-enum { DOSStubSize = 128 };
-}
-
 static yaml::BinaryRef
 toDebugS(ArrayRef<CodeViewYAML::YAMLDebugSubsection> Subsections,
          const codeview::StringsAndChecksums &SC, BumpPtrAllocator &Allocator) {
   using namespace codeview;
   ExitOnError Err("Error occurred writing .debug$S section");
   auto CVSS =
       Err(CodeViewYAML::toCodeViewSubsectionList(Allocator, Subsections, SC));
 
static bool layoutCOFF(COFFParser &CP) {
   }
 
   uint32_t SymbolTableStart = CurrentSectionDataOffset;
 
   // Calculate number of symbols.
   uint32_t NumberOfSymbols = 0;
   for (std::vector<COFFYAML::Symbol>::iterator i = CP.Obj.Symbols.begin(),
                                                e = CP.Obj.Symbols.end();
-                                               i != e; ++i) {
     uint32_t NumberOfAuxSymbols = 0;
     if (i->FunctionDefinition)
       NumberOfAuxSymbols += 1;
     if (i->bfAndefSymbol)
       NumberOfAuxSymbols += 1;
     if (i->WeakExternal)
       NumberOfAuxSymbols += 1;
     if (!i->File.empty())
static bool layoutCOFF(COFFParser &CP) {
   // Store all the allocated start addresses in the header.
   CP.Obj.Header.NumberOfSections = CP.Obj.Sections.size();
   CP.Obj.Header.NumberOfSymbols = NumberOfSymbols;
   if (NumberOfSymbols > 0 || CP.StringTable.size() > 4)
     CP.Obj.Header.PointerToSymbolTable = SymbolTableStart;
   else
     CP.Obj.Header.PointerToSymbolTable = 0;
 
-  *reinterpret_cast<support::ulittle32_t *>(&CP.StringTable[0])
-    = CP.StringTable.size();
+  *reinterpret_cast<support::ulittle32_t *>(&CP.StringTable[0]) =
+      CP.StringTable.size();
 
   return true;
 }
 
-template <typename value_type>
-struct binary_le_impl {
+template <typename value_type> struct binary_le_impl {
   value_type Value;
   binary_le_impl(value_type V) : Value(V) {}
 };
 
 template <typename value_type>
-raw_ostream &operator <<( raw_ostream &OS
-                        , const binary_le_impl<value_type> &BLE) {
+raw_ostream &operator<<(raw_ostream &OS,
+                        const binary_le_impl<value_type> &BLE) {
   char Buffer[sizeof(BLE.Value)];
   support::endian::write<value_type, support::little, support::unaligned>(
       Buffer, BLE.Value);
   OS.write(Buffer, sizeof(BLE.Value));
   return OS;
 }
 
 template <typename value_type>
 binary_le_impl<value_type> binary_le(value_type V) {
   return binary_le_impl<value_type>(V);
 }
 
 template <size_t NumBytes> struct zeros_impl {};
 
 template <size_t NumBytes>
 raw_ostream &operator<<(raw_ostream &OS, const zeros_impl<NumBytes> &) {
   char Buffer[NumBytes];
   memset(Buffer, 0, sizeof(Buffer));
   OS.write(Buffer, sizeof(Buffer));
   return OS;
 }
 
-template <typename T>
-zeros_impl<sizeof(T)> zeros(const T &) {
+template <typename T> zeros_impl<sizeof(T)> zeros(const T &) {
   return zeros_impl<sizeof(T)>();
 }
 
 template <typename T>
-static uint32_t initializeOptionalHeader(COFFParser &CP, uint16_t Magic, T Header) {
+static uint32_t initializeOptionalHeader(COFFParser &CP, uint16_t Magic,
+                                         T Header) {
   memset(Header, 0, sizeof(*Header));
   Header->Magic = Magic;
   Header->SectionAlignment = CP.Obj.OptionalHeader->Header.SectionAlignment;
   Header->FileAlignment = CP.Obj.OptionalHeader->Header.FileAlignment;
   uint32_t SizeOfCode = 0, SizeOfInitializedData = 0,
            SizeOfUninitializedData = 0;
   uint32_t SizeOfHeaders = alignTo(CP.SectionTableStart + CP.SectionTableSize,
                                    Header->FileAlignment);
static uint32_t initializeOptionalHeader(COFFParser &CP, uint16_t Magic,
   Header->SizeOfUninitializedData = SizeOfUninitializedData;
   Header->AddressOfEntryPoint =
       CP.Obj.OptionalHeader->Header.AddressOfEntryPoint; // RVA
   Header->ImageBase = CP.Obj.OptionalHeader->Header.ImageBase;
   Header->MajorOperatingSystemVersion =
       CP.Obj.OptionalHeader->Header.MajorOperatingSystemVersion;
   Header->MinorOperatingSystemVersion =
       CP.Obj.OptionalHeader->Header.MinorOperatingSystemVersion;
-  Header->MajorImageVersion =
-      CP.Obj.OptionalHeader->Header.MajorImageVersion;
-  Header->MinorImageVersion =
-      CP.Obj.OptionalHeader->Header.MinorImageVersion;
+  Header->MajorImageVersion = CP.Obj.OptionalHeader->Header.MajorImageVersion;
+  Header->MinorImageVersion = CP.Obj.OptionalHeader->Header.MinorImageVersion;
   Header->MajorSubsystemVersion =
       CP.Obj.OptionalHeader->Header.MajorSubsystemVersion;
   Header->MinorSubsystemVersion =
       CP.Obj.OptionalHeader->Header.MinorSubsystemVersion;
   Header->SizeOfImage = SizeOfImage;
   Header->SizeOfHeaders = SizeOfHeaders;
   Header->Subsystem = CP.Obj.OptionalHeader->Header.Subsystem;
   Header->DLLCharacteristics = CP.Obj.OptionalHeader->Header.DLLCharacteristics;
if (CP.isPE()) {
     // should live.
     OS.write_zeros(DOSStubSize - sizeof(DH));
     // Write out the PE signature.
     OS.write(COFF::PEMagic, sizeof(COFF::PEMagic));
   }
   if (CP.useBigObj()) {
     OS << binary_le(static_cast<uint16_t>(COFF::IMAGE_FILE_MACHINE_UNKNOWN))
        << binary_le(static_cast<uint16_t>(0xffff))
-       << binary_le(static_cast<uint16_t>(COFF::BigObjHeader::MinBigObjectVersion))
+       << binary_le(
+              static_cast<uint16_t>(COFF::BigObjHeader::MinBigObjectVersion))
        << binary_le(CP.Obj.Header.Machine)
        << binary_le(CP.Obj.Header.TimeDateStamp);
     OS.write(COFF::BigObjMagic, sizeof(COFF::BigObjMagic));
-    OS << zeros(uint32_t(0))
-       << zeros(uint32_t(0))
-       << zeros(uint32_t(0))
-       << zeros(uint32_t(0))
-       << binary_le(CP.Obj.Header.NumberOfSections)
+    OS << zeros(uint32_t(0)) << zeros(uint32_t(0)) << zeros(uint32_t(0))
+       << zeros(uint32_t(0)) << binary_le(CP.Obj.Header.NumberOfSections)
        << binary_le(CP.Obj.Header.PointerToSymbolTable)
        << binary_le(CP.Obj.Header.NumberOfSymbols);
   } else {
     OS << binary_le(CP.Obj.Header.Machine)
        << binary_le(static_cast<int16_t>(CP.Obj.Header.NumberOfSections))
        << binary_le(CP.Obj.Header.TimeDateStamp)
        << binary_le(CP.Obj.Header.PointerToSymbolTable)
        << binary_le(CP.Obj.Header.NumberOfSymbols)
        << binary_le(CP.Obj.Header.SizeOfOptionalHeader)
        << binary_le(CP.Obj.Header.Characteristics);
   }
   if (CP.isPE()) {
     if (CP.is64Bit()) {
       object::pe32plus_header PEH;
       initializeOptionalHeader(CP, COFF::PE32Header::PE32_PLUS, &PEH);
       OS.write(reinterpret_cast<char *>(&PEH), sizeof(PEH));
     } else {
       object::pe32_header PEH;
-      uint32_t BaseOfData = initializeOptionalHeader(CP, COFF::PE32Header::PE32, &PEH);
+      uint32_t BaseOfData =
+          initializeOptionalHeader(CP, COFF::PE32Header::PE32, &PEH);
       PEH.BaseOfData = BaseOfData;
       OS.write(reinterpret_cast<char *>(&PEH), sizeof(PEH));
     }
     for (const Optional<COFF::DataDirectory> &DD :
          CP.Obj.OptionalHeader->DataDirectories) {
       if (!DD.hasValue()) {
         OS << zeros(uint32_t(0));
         OS << zeros(uint32_t(0));
       } else {
         OS << binary_le(DD->RelativeVirtualAddress);
         OS << binary_le(DD->Size);
       }
     }
     OS << zeros(uint32_t(0));
     OS << zeros(uint32_t(0));
   }
 
   assert(OS.tell() == CP.SectionTableStart);
   // Output section table.
   for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
                                                 e = CP.Obj.Sections.end();
-                                                i != e; ++i) {
     OS.write(i->Header.Name, COFF::NameSize);
     OS << binary_le(i->Header.VirtualSize)
        << binary_le(i->Header.VirtualAddress)
        << binary_le(i->Header.SizeOfRawData)
        << binary_le(i->Header.PointerToRawData)
        << binary_le(i->Header.PointerToRelocations)
        << binary_le(i->Header.PointerToLineNumbers)
        << binary_le(i->Header.NumberOfRelocations)
for (const COFFYAML::Relocation &R : S.Relocations) {
       if (R.SymbolTableIndex) {
         if (!R.SymbolName.empty())
           WithColor::error()
               << "Both SymbolName and SymbolTableIndex specified\n";
         SymbolTableIndex = *R.SymbolTableIndex;
       } else {
         SymbolTableIndex = SymbolTableIndexMap[R.SymbolName];
       }
-      OS << binary_le(R.VirtualAddress)
-         << binary_le(SymbolTableIndex)
+      OS << binary_le(R.VirtualAddress) << binary_le(SymbolTableIndex)
          << binary_le(R.Type);
     }
   }
 
   // Output symbol table.
 
   for (std::vector<COFFYAML::Symbol>::const_iterator i = CP.Obj.Symbols.begin(),
                                                      e = CP.Obj.Symbols.end();
-                                                     i != e; ++i) {
     OS.write(i->Header.Name, COFF::NameSize);
     OS << binary_le(i->Header.Value);
     if (CP.useBigObj())
-       OS << binary_le(i->Header.SectionNumber);
     else
-       OS << binary_le(static_cast<int16_t>(i->Header.SectionNumber));
-    OS << binary_le(i->Header.Type)
-       << binary_le(i->Header.StorageClass)
+    OS << binary_le(i->Header.Type) << binary_le(i->Header.StorageClass)
        << binary_le(i->Header.NumberOfAuxSymbols);
 
     if (i->FunctionDefinition) {
       OS << binary_le(i->FunctionDefinition->TagIndex)
          << binary_le(i->FunctionDefinition->TotalSize)
          << binary_le(i->FunctionDefinition->PointerToLinenumber)
          << binary_le(i->FunctionDefinition->PointerToNextFunction)
          << zeros(i->FunctionDefinition->unused);
if (i->SectionDefinition) {
          << binary_le(i->SectionDefinition->CheckSum)
          << binary_le(static_cast<int16_t>(i->SectionDefinition->Number))
          << binary_le(i->SectionDefinition->Selection)
          << zeros(i->SectionDefinition->unused)
          << binary_le(static_cast<int16_t>(i->SectionDefinition->Number >> 16));
       OS.write_zeros(CP.getSymbolSize() - COFF::Symbol16Size);
     }
     if (i->CLRToken) {
-      OS << binary_le(i->CLRToken->AuxType)
-         << zeros(i->CLRToken->unused1)
+      OS << binary_le(i->CLRToken->AuxType) << zeros(i->CLRToken->unused1)
          << binary_le(i->CLRToken->SymbolTableIndex)
          << zeros(i->CLRToken->unused2);
       OS.write_zeros(CP.getSymbolSize() - COFF::Symbol16Size);
     }
   }
 
   // Output string table.
   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);
   if (!CP.parse()) {
     errs() << "yaml2obj: Failed to parse YAML file!\n";
     return 1;
   }
 
   if (!layoutOptionalHeader(CP)) {
     errs() << "yaml2obj: Failed to layout optional header for COFF file!\n";
     return 1;
   }
 
   if (!layoutCOFF(CP)) {
     errs() << "yaml2obj: Failed to layout COFF file!\n";
     return 1;
   }
   if (!writeCOFF(CP, Out)) {
     errs() << "yaml2obj: Failed to write COFF file!\n";
     return 1;
   }
   return 0;
 }
+
+} // namespace yaml
+} // namespace llvm

llvm/lib/ObjectYAML/ELFEmitter.cpp

 //===- yaml2elf - Convert YAML to a ELF object file -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// The ELF component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "yaml2obj.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
-#include "llvm/ADT/StringSet.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/EndianStream.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;
 
public:
   ContiguousBlobAccumulator(uint64_t InitialOffset_)
       : InitialOffset(InitialOffset_), Buf(), OS(Buf) {}
   template <class Integer>
   raw_ostream &getOSAndAlignedOffset(Integer &Offset, unsigned Align) {
     Offset = padToAlignment(Align);
     return OS;
   }
   void writeBlobToStream(raw_ostream &Out) { Out << OS.str(); }
 };
-} // end anonymous namespace
 
 // Used to keep track of section and symbol names, so that in the YAML file
 // sections and symbols can be referenced by name instead of by index.
-namespace {
 class NameToIdxMap {
   StringMap<unsigned> Map;
 
 public:
   /// \Returns false if name is already present in the map.
   bool addName(StringRef Name, unsigned Ndx) {
     return Map.insert({Name, Ndx}).second;
   }
unsigned get(StringRef Name) const {
     unsigned Idx;
     if (lookup(Name, Idx))
       return Idx;
     assert(false && "Expected section not found in index");
     return 0;
   }
   unsigned size() const { return Map.size(); }
 };
-} // 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));
-}
-
-namespace {
 /// "Single point of truth" for the ELF file construction.
 /// TODO: This class still has a ways to go before it is truly a "single
 /// point of truth".
-template <class ELFT>
-class ELFState {
+template <class ELFT> class ELFState {
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::Relr Elf_Relr;
   typedef typename ELFT::Dyn Elf_Dyn;

 public:
   static int writeELF(raw_ostream &OS, ELFYAML::Object &Doc);
 
 private:
   void finalizeStrings();
 };
 } // end anonymous namespace
 
-template <class ELFT>
-ELFState<ELFT>::ELFState(ELFYAML::Object &D) : Doc(D) {
+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) {
   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(
         Doc.Sections.begin(),
         llvm::make_unique<ELFYAML::Section>(
             ELFYAML::Section::SectionKind::RawContent, /*IsImplicit=*/true));
 
   std::vector<StringRef> ImplicitSections = {".symtab", ".strtab", ".shstrtab"};
   if (!Doc.DynamicSymbols.empty())
     ImplicitSections.insert(ImplicitSections.end(), {".dynsym", ".dynstr"});
 
   // Insert placeholders for implicit sections that are not
   // defined explicitly in YAML.
   for (StringRef SecName : ImplicitSections) {
     if (DocSections.count(SecName))
       continue;
 
     std::unique_ptr<ELFYAML::Section> Sec = llvm::make_unique<ELFYAML::Section>(
         ELFYAML::Section::SectionKind::RawContent, true /*IsImplicit*/);
     Sec->Name = SecName;
     Doc.Sections.push_back(std::move(Sec));
   }
 }
 
-template <class ELFT>
-void ELFState<ELFT>::initELFHeader(Elf_Ehdr &Header) {
+template <class ELFT> void ELFState<ELFT>::initELFHeader(Elf_Ehdr &Header) {
   using namespace llvm::ELF;
   zero(Header);
   Header.e_ident[EI_MAG0] = 0x7f;
   Header.e_ident[EI_MAG1] = 'E';
   Header.e_ident[EI_MAG2] = 'L';
   Header.e_ident[EI_MAG3] = 'F';
   Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
   Header.e_ident[EI_DATA] = Doc.Header.Data;

 
 static bool isMips64EL(const ELFYAML::Object &Doc) {
   return Doc.Header.Machine == ELFYAML::ELF_EM(llvm::ELF::EM_MIPS) &&
          Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64) &&
          Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
 }
 
 template <class ELFT>
-bool
-ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
-                                    const ELFYAML::RelocationSection &Section,
-                                    ContiguousBlobAccumulator &CBA) {
+bool ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::RelocationSection &Section,
   assert((Section.Type == llvm::ELF::SHT_REL ||
           Section.Type == llvm::ELF::SHT_RELA) &&
          "Section type is not SHT_REL nor SHT_RELA");
 
   bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
   SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   SHeader.sh_size = SHeader.sh_entsize * Section.Relocations.size();
 
if (Section.Content)
     SHeader.sh_size = Section.Content->binary_size();
   else
     SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries.size();
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = sizeof(Elf_Dyn);
 
-  raw_ostream &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   for (const ELFYAML::DynamicEntry &DE : Section.Entries) {
     support::endian::write<uintX_t>(OS, DE.Tag, ELFT::TargetEndianness);
     support::endian::write<uintX_t>(OS, DE.Val, ELFT::TargetEndianness);
   }
   if (Section.Content)
     Section.Content->writeAsBinary(OS);
 
   return true;
int ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc) {
 
   OS.write((const char *)&Header, sizeof(Header));
   writeArrayData(OS, makeArrayRef(PHeaders));
   writeArrayData(OS, makeArrayRef(SHeaders));
   CBA.writeBlobToStream(OS);
   return 0;
 }
 
+namespace llvm {
+namespace yaml {
+
 int yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out) {
   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);
   }
   if (IsLE)
     return ELFState<object::ELF32LE>::writeELF(Out, Doc);
   return ELFState<object::ELF32BE>::writeELF(Out, Doc);
 }
+
+} // namespace yaml
+} // namespace llvm

llvm/lib/ObjectYAML/LLVMBuild.txt

 ;===------------------------------------------------------------*- Conf -*--===;
 ;
 ; 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
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = ObjectYAML
 parent = Libraries
-required_libraries = Object Support DebugInfoCodeView
+required_libraries = Object Support DebugInfoCodeView MC

llvm/lib/ObjectYAML/MachOEmitter.cpp

 //===- yaml2macho - Convert YAML to a Mach object file --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// The Mach component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "yaml2obj.h"
 #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;
#include "llvm/BinaryFormat/MachO.def"
     if (BytesRemaining > 0) {
       ZeroFillBytes(OS, BytesRemaining);
     }
   }
   return Error::success();
 }
 
 static bool isVirtualSection(uint8_t type) {
-  return (type == MachO::S_ZEROFILL ||
-          type == MachO::S_GB_ZEROFILL ||
+  return (type == MachO::S_ZEROFILL || type == MachO::S_GB_ZEROFILL ||
           type == MachO::S_THREAD_LOCAL_ZEROFILL);
 }
 
 Error 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)) {
+      if (0 ==
+          strncmp(&LC.Data.segment_command_data.segname[0], "__LINKEDIT", 16)) {
         FoundLinkEditSeg = true;
         if (auto Err = writeLinkEditData(OS))
           return Err;
       }
       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.

 void UniversalWriter::ZeroToOffset(raw_ostream &OS, size_t Offset) {
   auto currOffset = OS.tell() - fileStart;
   if (currOffset < Offset)
     ZeroFillBytes(OS, Offset - currOffset);
 }
 
 } // end anonymous namespace
 
-int yaml2macho(yaml::YamlObjectFile &Doc, raw_ostream &Out) {
+namespace llvm {
+namespace yaml {
+
+int yaml2macho(YamlObjectFile &Doc, raw_ostream &Out) {
   UniversalWriter Writer(Doc);
   if (auto Err = Writer.writeMachO(Out)) {
     errs() << toString(std::move(Err));
     return 1;
   }
   return 0;
 }
+
+} // namespace yaml
+} // namespace llvm

llvm/lib/ObjectYAML/MinidumpEmitter.cpp

 //===- yaml2minidump.cpp - Convert a YAML file to a minidump file ---------===//
 //
 // 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 "yaml2obj.h"
 #include "llvm/ObjectYAML/MinidumpYAML.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
+namespace llvm {
+namespace yaml {
+
 int yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out) {
   writeAsBinary(Doc, Out);
   return 0;
 }
+
+} // namespace yaml
+} // namespace llvm

llvm/lib/ObjectYAML/WasmEmitter.cpp

 //===- yaml2wasm - Convert YAML to a Wasm object file --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// The Wasm component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 //
 
 #include "llvm/Object/Wasm.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/LEB128.h"
 
 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);
 
 private:
   int writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
                         uint32_t SectionIndex);
 
private:
   int writeSectionContent(raw_ostream &OS,
                           WasmYAML::TargetFeaturesSection &Section);
   WasmYAML::Object &Obj;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedEvents = 0;
 };
 
+class SubSectionWriter {
+  raw_ostream &OS;
+  std::string OutString;
+  raw_string_ostream StringStream;
+
+public:
+  SubSectionWriter(raw_ostream &OS) : OS(OS), StringStream(OutString) {}
+
+  void done() {
+    StringStream.flush();
+    encodeULEB128(OutString.size(), OS);
+    OS << OutString;
+    OutString.clear();
+  }
+
+  raw_ostream &getStream() { return StringStream; }
+};
+
+} // end anonymous namespace
+
 static int writeUint64(raw_ostream &OS, uint64_t Value) {
   char Data[sizeof(Value)];
   support::endian::write64le(Data, Value);
   OS.write(Data, sizeof(Data));
   return 0;
 }
 
 static int writeUint32(raw_ostream &OS, uint32_t Value) {
static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
   default:
     errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode << "\n";
     return 1;
   }
   writeUint8(OS, wasm::WASM_OPCODE_END);
   return 0;
 }
 
-class SubSectionWriter {
-  raw_ostream &OS;
-  std::string OutString;
-  raw_string_ostream StringStream;
-
-public:
-  SubSectionWriter(raw_ostream &OS) : OS(OS), StringStream(OutString) {}
-
-  void done() {
-    StringStream.flush();
-    encodeULEB128(OutString.size(), OS);
-    OS << OutString;
-    OutString.clear();
-  }
-
-  raw_ostream &getStream() { return StringStream; }
-};
-
 int 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 (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
 
     encodeULEB128(OutString.size(), OS);
     OS << OutString;
   }
 
   return 0;
 }
 
-int yaml2wasm(llvm::WasmYAML::Object &Doc, raw_ostream &Out) {
+namespace llvm {
+namespace yaml {
+
+int yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out) {
   WasmWriter Writer(Doc);
 
   return Writer.writeWasm(Out);
 }
+
+} // namespace yaml
+} // namespace llvm

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/Object/ObjectFile.h"
+#include "llvm/ObjectYAML/ObjectYAML.h"
+#include "llvm/Support/Errc.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();
+  };
+
+  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!");
+    }
+  } while (YIn.nextDocument());
+
+  return createStringError(errc::invalid_argument,
+                           "Cannot find the %u%s document", DocNum,
+                           getOrdinalSuffix(DocNum).data());
+}
+
+Expected<std::unique_ptr<object::ObjectFile>>
+yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml) {
+  Storage.clear();
+  raw_svector_ostream OS(Storage);
+
+  yaml::Input YIn(Yaml);
+  if (Error E = convertYAML(YIn, OS))
+    return std::move(E);
+
+  return object::ObjectFile::createObjectFile(
+      MemoryBufferRef(OS.str(), "YamlObject"));
+}
+
+} // namespace yaml
+} // namespace llvm

llvm/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: yaml2obj: Unknown document type!
+# CHECK: yaml2obj: error: Unknown document type!
 
 # RUN: echo -e -n "\xff" | not yaml2obj 2>&1 | FileCheck %s --check-prefix=INVALID
-# INVALID: yaml2obj: Failed to parse YAML file!
+# INVALID: yaml2obj: error: Failed to parse YAML input!

llvm/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: yaml2obj: error: Cannot find the 3rd document
+
+# RUN: not yaml2obj %s --docnum=76768677 2>&1 | FileCheck %s --check-prefix=TWO
+# 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

llvm/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: yaml2obj: Failed to parse YAML file!
+# CHECK: yaml2obj: error: Failed to parse YAML input!

llvm/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: yaml2obj: Cannot find the 5th document
+# DOC5: yaml2obj: error: Cannot find the 5th document
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS32
   Data: ELFDATA2LSB
   Type: ET_REL
   Machine: EM_MIPS
   Flags: [EF_MIPS_CPIC]

llvm/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: yaml2obj: Failed to parse YAML file!
+# ERR2-NEXT: yaml2obj: error: Failed to parse YAML input!

llvm/tools/yaml2obj/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
-  DebugInfoCodeView
-  MC
-  Object
   ObjectYAML
   Support
   )
 
 add_llvm_tool(yaml2obj
   yaml2obj.cpp
-  yaml2coff.cpp
-  yaml2elf.cpp
-  yaml2macho.cpp
-  yaml2minidump.cpp
-  yaml2wasm.cpp
   )

llvm/tools/yaml2obj/yaml2obj.cpp

 //===- yaml2obj - Convert YAML to a binary object file --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This program takes a YAML description of an object file and outputs the
 // binary equivalent.
 //
 // This is used for writing tests that require binary files.
 //
 //===----------------------------------------------------------------------===//
 
-#include "yaml2obj.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 using namespace llvm;
 
 static cl::opt<std::string>
   Input(cl::Positional, cl::desc("<input>"), cl::init("-"));
 
 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);
 }
 
-static int convertYAML(yaml::Input &YIn, raw_ostream &Out) {
-  unsigned CurDocNum = 0;
-  do {
-    if (++CurDocNum == DocNum) {
-      yaml::YamlObjectFile Doc;
-      YIn >> Doc;
-      if (YIn.error())
-        error("yaml2obj: Failed to parse YAML file!");
-      if (Doc.Elf)
-        return yaml2elf(*Doc.Elf, Out);
-      if (Doc.Coff)
-        return yaml2coff(*Doc.Coff, Out);
-      if (Doc.MachO || Doc.FatMachO)
-        return yaml2macho(Doc, Out);
-      if (Doc.Minidump)
-        return yaml2minidump(*Doc.Minidump, Out);
-      if (Doc.Wasm)
-        return yaml2wasm(*Doc.Wasm, Out);
-      error("yaml2obj: Unknown document type!");
-    }
-  } while (YIn.nextDocument());
-
-  error("yaml2obj: Cannot find the " + Twine(DocNum) +
-        llvm::getOrdinalSuffix(DocNum) + " document");
-}
-
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv);
 
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   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());
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
       MemoryBuffer::getFileOrSTDIN(Input);
   if (!Buf)
     return 1;
 
   yaml::Input YIn(Buf.get()->getBuffer());
-  int Res = convertYAML(YIn, Out->os());
-  if (Res == 0)
-    Out->keep();
+  if (Error E = convertYAML(YIn, Out->os(), DocNum)) {
+    logAllUnhandledErrors(std::move(E), WithColor::error(errs(), argv[0]));
+    return 1;
+  }
 
+  Out->keep();
   Out->os().flush();
-  return Res;
+  return 0;
 }

llvm/unittests/ObjectYAML/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Object
   ObjectYAML
   )
 
 add_llvm_unittest(ObjectYAMLTests
   MinidumpYAMLTest.cpp
+  YAML2ObjTest.cpp
   YAMLTest.cpp
   )
 
 target_link_libraries(ObjectYAMLTests PRIVATE LLVMTestingSupport)

llvm/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/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace object;
+using namespace yaml;
+
+TEST(yaml2ObjectFile, ELF) {
+  SmallString<0> Storage;
+  Expected<std::unique_ptr<ObjectFile>> ErrOrObj = yaml2ObjectFile(Storage, R"(
+--- !ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64)");
+
+  ASSERT_THAT_EXPECTED(ErrOrObj, Succeeded());
+
+  std::unique_ptr<ObjectFile> ObjFile = std::move(ErrOrObj.get());
+
+  ASSERT_TRUE(ObjFile->isELF());
+  ASSERT_TRUE(ObjFile->isRelocatableObject());
+}