#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 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
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
)
///
//===----------------------------------------------------------------------===//
-#include "yaml2obj.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.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"
using namespace llvm;
+namespace {
+
/// This parses a yaml stream that represents a COFF object file.
/// See docs/yaml2obj for the yaml scheema.
struct COFFParser {
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
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
} 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;
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) {
return true;
}
-namespace {
-enum { DOSStubSize = 128 };
-}
-
static yaml::BinaryRef
toDebugS(ArrayRef<CodeViewYAML::YAMLDebugSubsection> Subsections,
const codeview::StringsAndChecksums &SC, BumpPtrAllocator &Allocator) {
uint32_t NumberOfSymbols = 0;
for (std::vector<COFFYAML::Symbol>::iterator i = CP.Obj.Symbols.begin(),
e = CP.Obj.Symbols.end();
- i != e; ++i) {
+ i != e; ++i) {
uint32_t NumberOfAuxSymbols = 0;
if (i->FunctionDefinition)
NumberOfAuxSymbols += 1;
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);
+ Buffer, BLE.Value);
OS.write(Buffer, sizeof(BLE.Value));
return OS;
}
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;
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 =
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.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));
}
// Output section table.
for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
e = CP.Obj.Sections.end();
- i != e; ++i) {
+ i != e; ++i) {
OS.write(i->Header.Name, COFF::NameSize);
OS << binary_le(i->Header.VirtualSize)
<< binary_le(i->Header.VirtualAddress)
} 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);
}
}
for (std::vector<COFFYAML::Symbol>::const_iterator i = CP.Obj.Symbols.begin(),
e = CP.Obj.Symbols.end();
- i != e; ++i) {
+ 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);
+ 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(static_cast<int16_t>(i->Header.SectionNumber));
+ OS << binary_le(i->Header.Type) << binary_le(i->Header.StorageClass)
<< binary_le(i->Header.NumberOfAuxSymbols);
if (i->FunctionDefinition) {
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);
return true;
}
+namespace llvm {
+namespace yaml {
+
int yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out) {
COFFParser CP(Doc);
if (!CP.parse()) {
}
return 0;
}
+
+} // namespace yaml
+} // namespace llvm
///
//===----------------------------------------------------------------------===//
-#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"
}
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;
}
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;
};
} // 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())
Doc.Sections.insert(
Doc.Sections.begin(),
llvm::make_unique<ELFYAML::Section>(
- ELFYAML::Section::SectionKind::RawContent, /*IsImplicit=*/true));
+ ELFYAML::Section::SectionKind::RawContent, /*IsImplicit=*/true));
std::vector<StringRef> ImplicitSections = {".symtab", ".strtab", ".shstrtab"};
if (!Doc.DynamicSymbols.empty())
}
}
-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;
}
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,
+ ContiguousBlobAccumulator &CBA) {
assert((Section.Type == llvm::ELF::SHT_REL ||
Section.Type == llvm::ELF::SHT_RELA) &&
"Section type is not SHT_REL nor SHT_RELA");
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);
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);
return ELFState<object::ELF32LE>::writeELF(Out, Doc);
return ELFState<object::ELF32BE>::writeELF(Out, Doc);
}
+
+} // namespace yaml
+} // namespace llvm
type = Library
name = ObjectYAML
parent = Libraries
-required_libraries = Object Support DebugInfoCodeView
+required_libraries = Object Support DebugInfoCodeView MC
///
//===----------------------------------------------------------------------===//
-#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"
}
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);
}
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;
} // 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 0;
}
+
+} // namespace yaml
+} // namespace llvm
//
//===----------------------------------------------------------------------===//
-#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
#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 {
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);
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);
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
--- /dev/null
+//===-- 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
# 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!
--- /dev/null
+## 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
...
# 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!
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
)
//
//===----------------------------------------------------------------------===//
-#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/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>
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);
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;
}
add_llvm_unittest(ObjectYAMLTests
MinidumpYAMLTest.cpp
+ YAML2ObjTest.cpp
YAMLTest.cpp
)
--- /dev/null
+//===- 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());
+}
projects / llvm / commitdiff