[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

31

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/yaml2wasm.cpp

655

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

51

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.

17–22

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

9

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/yaml2wasm.cpp

655

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

31

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/yaml2wasm.cpp

655

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 ↗

(On Diff #211876)

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/test/tools/yaml2obj/invalid-docnum.test

1 ↗

(On Diff #211998)

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."

llvm/tools/yaml2obj/yaml2coff.cpp

34

This struct should be in the anonymous namespace.

llvm/tools/yaml2obj/yaml2elf.cpp

58

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

llvm/tools/yaml2obj/yaml2wasm.cpp

25

This class should be in the anonymous namespace.

[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 <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);
+
+int 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
   COFFYAML.cpp
   DWARFEmitter.cpp
   DWARFVisitor.cpp
   DWARFYAML.cpp
   ELFYAML.cpp
   MachOYAML.cpp
   ObjectYAML.cpp
   MinidumpYAML.cpp
   WasmYAML.cpp
   XCOFFYAML.cpp
   YAML.cpp
+  yaml2coff.cpp
+  yaml2elf.cpp
+  yaml2macho.cpp
+  yaml2obj.cpp
+  yaml2minidump.cpp
+  yaml2wasm.cpp
   )

llvm/lib/ObjectYAML/yaml2coff.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;
static bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
   }
 
   // Output string table.
   if (CP.Obj.Header.PointerToSymbolTable)
     OS.write(&CP.StringTable[0], CP.StringTable.size());
   return true;
 }
 
-int yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out) {
+int yaml::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";

llvm/lib/ObjectYAML/yaml2elf.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/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/ADT/StringSet.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;
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;
 }
 
-int yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out) {
+int yaml::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);
 }

llvm/lib/ObjectYAML/yaml2macho.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;

 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) {
+int yaml::yaml2macho(yaml::YamlObjectFile &Doc, raw_ostream &Out) {
   UniversalWriter Writer(Doc);
   if (auto Err = Writer.writeMachO(Out)) {
     errs() << toString(std::move(Err));
     return 1;
   }
   return 0;
 }

llvm/lib/ObjectYAML/yaml2minidump.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;
 
-int yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out) {
+int yaml::yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out) {
   writeAsBinary(Doc, Out);
   return 0;
 }

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 {
+
+LLVM_ATTRIBUTE_NORETURN static void error(Twine Message) {
+  errs() << Message << "\n";
+  exit(1);
+}
+
+int convertYAML(yaml::Input &YIn, raw_ostream &Out, unsigned DocNum) {
+  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");
+}
+
+Expected<std::unique_ptr<object::ObjectFile>>
+yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml) {
+  Storage.clear();
+  raw_svector_ostream OS(Storage);
+
+  yaml::Input YIn(Yaml);
+  if (convertYAML(YIn, OS))
+    return createStringError(errc::invalid_argument, "Invalid YAML");
+
+  return object::ObjectFile::createObjectFile(
+      MemoryBufferRef(OS.str(), "YamlObject"));
+}
+
+} // namespace yaml
+} // namespace llvm

llvm/lib/ObjectYAML/yaml2wasm.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;
 
 /// This parses a yaml stream that represents a Wasm object file.
 /// See docs/yaml2obj for the yaml scheema.
 class WasmWriter {
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) {
+int llvm::yaml::yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out) {
   WasmWriter Writer(Doc);
 
   return Writer.writeWasm(Out);
 }

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/ADT/StringExtras.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
+#include "llvm/ObjectYAML/yaml2obj.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/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>

 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::F_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());
+  int Res = convertYAML(YIn, Out->os(), DocNum);
   if (Res == 0)
     Out->keep();
 
   Out->os().flush();
   return Res;
 }

llvm/unittests/ObjectYAML/CMakeLists.txt

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

llvm/unittests/ObjectYAML/yaml2ObjectFileTest.cpp

+//===- yaml2ObjectFileTest.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/ADT/SmallString.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/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_TRUE(!!ErrOrObj);
+
+  std::unique_ptr<ObjectFile> ObjFile = std::move(ErrOrObj.get());
+
+  ASSERT_TRUE(ObjFile->isELF());
+  ASSERT_TRUE(ObjFile->isRelocatableObject());
+}