[XCOFF] Add functionality for parsing AIX XCOFF object files header .

[DiggerLin]

Summary

1. Add functionality for parsing AIX XCOFF object files header .
2. Only support 32bits AIX XCOFF object files in the patch
3. Print out the AIX XCOFF object file header as YAML format.

[hubert.reinterpretcast]

llvm/include/llvm/Object/XCOFFObjectFile.h

45

When _XCOFF_UOFFSET is set, the AIX headers treat this field as unsigned. Indications are that values greater than those of the corresponding signed type are indeed valid (despite difficulties in using files with such values with the AIX system linker).

llvm/lib/Object/XCOFFObjectFile.cpp

242

getObject below does size checking too. What does having this check here add?

[sfertile]

I've added a few reviewers who have committed to the other file formats recently since none of us have a lot of experience with this part of llvm.

llvm/include/llvm/Object/XCOFFObjectFile.h

37

Rather then defining these in the llvm::object namespace why not drop the XCOFF part of the name and make the defintion nested inside XCOFFObjectFile?

54

The only use of this is in XCOFFObjectFile.cpp, it should be defined there instead of in the header.

[rnk]

The skeleton of the dumper seems fine.

My main question would be, how is this going to fit into MC and the rest of LLVM? We support 4(?) object file formats there now (ELF, COFF (pretty much assumes Windows), wasm, and MachO), and MC is not designed to be very extensible. Will Triple::isOSBinFormatCOFF return true for XCOFF, or will it be distinct?

llvm/include/llvm/Object/XCOFFObjectFile.h

37

(Not to bikeshed too much...) Personally, I'd leave this as is. It's consistent with the other object formats. It's useful to be able to do using namespace llvm::object;, but you cannot shorten XCOFFObjectFile::Header without a typedef or type alias.

[sfertile]

In D59419#1435075, @rnk wrote:

My main question would be, how is this going to fit into MC and the rest of LLVM? We support 4(?) object file formats there now (ELF, COFF (pretty much assumes Windows), wasm, and MachO), and MC is not designed to be very extensible. Will Triple::isOSBinFormatCOFF return true for XCOFF, or will it be distinct?

Our intention is for XCOFF to be a distinct object file format. We had a look at the Windows COFF format and it does share some similarities with XCOFF, but overall I think they are too different to try to reconcile into a single COFF object file format. Jason already landed a patch for adding Aix and XCOFF to the triple (here) and we treat XCOFF as a distinct object format there as well.

[DiggerLin]

changed the code based on the comment.

1. changed the support::ubig32_t SymbolTableOffset;
2. move the getObject function to llvm/lib/Object/XCOFFObjectFile.cpp
3. deleted the checkSize function definition and removed the checkSize from XCOFFObjectFile::XCOFFObjectFile

llvm/include/llvm/Object/XCOFFObjectFile.h

37

I am agreed with Reid Kleckner.

45

changed to support::ubig32_t SymbolTableOffset

54

OK. I can move it to XCOFFObjectFile.cpp

llvm/lib/Object/XCOFFObjectFile.cpp

242

I have deleted the checkSize function definition and removed the check size here

[DiggerLin]

changed the code based on the comment.

1.changed the support::ubig32_t SymbolTableOffset;
2.move the getObject function to llvm/lib/Object/XCOFFObjectFile.cpp
3.deleted the checkSize function definition and removed the checkSize from XCOFFObjectFile::XCOFFObjectFile

[sfertile]

Other the a few minor nit picks, this LGTM.

llvm/include/llvm/Object/XCOFFObjectFile.h

37

Fair enough.

108

minor nit: add a blank line before the endif

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

12

blank line before the ifndef.

19

minor nit: no blank line between the 2 namespace openings.

49

blank again.

llvm/lib/ObjectYAML/XCOFFYAML.cpp

20

nit: remove white-space.

[hubert.reinterpretcast]

LGTM with minor changes.

llvm/lib/Object/XCOFFObjectFile.cpp

121

Minor nit: Naming is not consistent (ret versus Result).

llvm/lib/ObjectYAML/XCOFFYAML.cpp

17

I am not seeing a need for <cstdint> or <vector>. At the same time, <string.h> should be added for ::memset.

[DiggerLin]

April:

1. added some blank line and deleted some blank line as suggest.
2. deleted some header files #include "llvm/ObjectYAML/YAML.h"

#include "llvm/Support/YAMLTraits.h"
#include <cstdint>
from xcoffyaml.cpp

[DiggerLin]

llvm/include/llvm/Object/XCOFFObjectFile.h

108

done

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

19

deleted , thanks

49

added a blank line , thanks

llvm/lib/ObjectYAML/XCOFFYAML.cpp

17

I deleted the
-#include "llvm/ObjectYAML/YAML.h"
-#include "llvm/Support/YAMLTraits.h"
-#include <cstdint>
-#include <vector>

20

done

[DiggerLin]

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

12

done,thanks

llvm/lib/Object/XCOFFObjectFile.cpp

121

change to Result

llvm/lib/ObjectYAML/XCOFFYAML.cpp

17

I think <string.h> is already be included in the headers files which be included in #include "llvm/ObjectYAML/XCOFFYAML.h" ,and I tried to use -E of g++ to preprocessor the file , I can find the string.h in the preprocessor file.

[hubert.reinterpretcast]

llvm/lib/ObjectYAML/XCOFFYAML.cpp

17

Firstly, is ::memset part of the abstract interface (as opposed to an implementation-related detail) of any of the headers included directly by this file? I believe the answer is "no". Secondly, is <string.h> actually included by any of the headers in the LLVM project that are transitively included from this file? Of the 51 headers, none of them include <string.h> (although some include <cstring>, which does not have to declare ::memset).

The 51 headers I checked are:
llvm/ObjectYAML/YAML.h llvm/ADT/ArrayRef.h llvm/ADT/DenseMapInfo.h llvm/ADT/Hashing.h llvm/ADT/None.h llvm/ADT/Optional.h llvm/ADT/PointerIntPair.h llvm/ADT/PointerUnion.h llvm/ADT/STLExtras.h llvm/ADT/SmallString.h llvm/ADT/SmallVector.h llvm/ADT/StringExtras.h llvm/ADT/StringMap.h llvm/ADT/StringRef.h llvm/ADT/StringSwitch.h llvm/ADT/Twine.h llvm/ADT/iterator.h llvm/ADT/iterator_range.h llvm/Config/abi-breaking.h llvm/Config/llvm-config.h llvm/Support/AlignOf.h llvm/Support/Allocator.h llvm/Support/CBindingWrapping.h llvm/Support/Casting.h llvm/Support/Chrono.h llvm/Support/Compiler.h llvm/Support/DataTypes.h llvm/Support/Debug.h llvm/Support/Endian.h llvm/Support/Error.h llvm/Support/ErrorHandling.h llvm/Support/ErrorOr.h llvm/Support/FileSystem.h llvm/Support/Format.h llvm/Support/FormatProviders.h llvm/Support/FormatVariadicDetails.h llvm/Support/Host.h llvm/Support/MD5.h llvm/Support/MathExtras.h llvm/Support/MemAlloc.h llvm/Support/MemoryBuffer.h llvm/Support/NativeFormatting.h llvm/Support/PointerLikeTypeTraits.h llvm/Support/Regex.h llvm/Support/SMLoc.h llvm/Support/SourceMgr.h llvm/Support/SwapByteOrder.h llvm/Support/YAMLParser.h llvm/Support/YAMLTraits.h llvm/Support/raw_ostream.h llvm/Support/type_traits.h

[hubert.reinterpretcast]

@DiggerLin; as discussed off-list, I'll commit this for you with the additional change to include <string.h>.

[MaskRay]

llvm/trunk/lib/Object/XCOFFObjectFile.cpp

40 ↗

(On Diff #193639)

return; can be deleted

52 ↗

(On Diff #193639)

If you write llvm_unreachable (__builtin_unreachable() or __assume(false)), an return statement can be omitted.

llvm/include/llvm/BinaryFormat/Magic.h

enum Impl {
     macho_dsym_companion,                     ///< Mach-O dSYM companion file
     macho_kext_bundle,                        ///< Mach-O kext bundle file
     macho_universal_binary,                   ///< Mach-O universal binary
     coff_cl_gl_object,   ///< Microsoft cl.exe's intermediate code file
     coff_object,         ///< COFF object file
     coff_import_library, ///< COFF import library
     pecoff_executable,   ///< PECOFF executable file
     windows_resource,    ///< Windows compiled resource file (.res)
+    xcoff_object_32,     ///< 32-bit XCOFF object file
     wasm_object,         ///< WebAssembly Object file
     pdb,                 ///< Windows PDB debug info file
   };
 
   bool is_object() const { return V != unknown; }
 
   file_magic() = default;
   file_magic(Impl V) : V(V) {}

llvm/include/llvm/Object/Binary.h

enum {
     ID_COFFImportFile,
     ID_IR,                 // LLVM IR
 
     ID_WinRes, // Windows resource (.res) file.
 
     // Object and children.
     ID_StartObjects,
     ID_COFF,
+    ID_XCOFF32, // AIX XCOFF 32-bit
 
     ID_ELF32L, // ELF 32-bit, little endian
     ID_ELF32B, // ELF 32-bit, big endian
     ID_ELF64L, // ELF 64-bit, little endian
     ID_ELF64B, // ELF 64-bit, big endian
 
     ID_MachO32L, // MachO 32-bit, little endian
     ID_MachO32B, // MachO 32-bit, big endian
public:
   bool isMachO() const {
     return TypeID >= ID_MachO32L && TypeID <= ID_MachO64B;
   }
 
   bool isCOFF() const {
     return TypeID == ID_COFF;
   }
 
+  bool isXCOFF() const { return TypeID == ID_XCOFF32; }
+
   bool isWasm() const { return TypeID == ID_Wasm; }
 
   bool isCOFFImportFile() const {
     return TypeID == ID_COFFImportFile;
   }
 
   bool isIR() const {
     return TypeID == ID_IR;

llvm/include/llvm/Object/ObjectFile.h

public:
   static bool classof(const Binary *v) {
     return v->isObject();
   }
 
   static Expected<std::unique_ptr<COFFObjectFile>>
   createCOFFObjectFile(MemoryBufferRef Object);
 
   static Expected<std::unique_ptr<ObjectFile>>
+  createXCOFFObjectFile(MemoryBufferRef Object);
+
+  static Expected<std::unique_ptr<ObjectFile>>
   createELFObjectFile(MemoryBufferRef Object);
 
   static Expected<std::unique_ptr<MachOObjectFile>>
   createMachOObjectFile(MemoryBufferRef Object,
                         uint32_t UniversalCputype = 0,
                         uint32_t UniversalIndex = 0);
 
   static Expected<std::unique_ptr<WasmObjectFile>>

llvm/include/llvm/Object/XCOFFObjectFile.h

+//===- XCOFFObjectFile.h - XCOFF object file implementation -----*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the XCOFFObjectFile class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_XCOFFOBJECTFILE_H
+#define LLVM_OBJECT_XCOFFOBJECTFILE_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/Error.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <system_error>
+
+namespace llvm {
+namespace object {
+
+struct XCOFFFileHeader {
+  support::ubig16_t Magic;
+  support::ubig16_t NumberOfSections;
+
+  // Unix time value, value of 0 indicates no timestamp.
+  // Negative values are reserved.
+  support::big32_t TimeStamp;
+  
+  support::ubig32_t SymbolTableOffset; // File offset to symbol table.
+  support::big32_t NumberOfSymTableEntries;
+  support::ubig16_t AuxHeaderSize;
+  support::ubig16_t Flags;
+};
+
+class XCOFFObjectFile : public ObjectFile {
+private:
+  const XCOFFFileHeader *FileHdrPtr = nullptr;
+
+public:
+  void moveSymbolNext(DataRefImpl &Symb) const override;
+  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
+  basic_symbol_iterator symbol_begin() const override;
+  basic_symbol_iterator symbol_end() const override;
+
+  Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
+  Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
+  uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
+  uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
+  Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
+  Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
+
+  void moveSectionNext(DataRefImpl &Sec) const override;
+  std::error_code getSectionName(DataRefImpl Sec,
+                                 StringRef &Res) const override;
+  uint64_t getSectionAddress(DataRefImpl Sec) const override;
+  uint64_t getSectionIndex(DataRefImpl Sec) const override;
+  uint64_t getSectionSize(DataRefImpl Sec) const override;
+  std::error_code getSectionContents(DataRefImpl Sec,
+                                     StringRef &Res) const override;
+  uint64_t getSectionAlignment(DataRefImpl Sec) const override;
+  bool isSectionCompressed(DataRefImpl Sec) const override;
+  bool isSectionText(DataRefImpl Sec) const override;
+  bool isSectionData(DataRefImpl Sec) const override;
+  bool isSectionBSS(DataRefImpl Sec) const override;
+
+  bool isSectionVirtual(DataRefImpl Sec) const override;
+  relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
+  relocation_iterator section_rel_end(DataRefImpl Sec) const override;
+
+  void moveRelocationNext(DataRefImpl &Rel) const override;
+  uint64_t getRelocationOffset(DataRefImpl Rel) const override;
+  symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
+  uint64_t getRelocationType(DataRefImpl Rel) const override;
+  void getRelocationTypeName(DataRefImpl Rel,
+                             SmallVectorImpl<char> &Result) const override;
+
+  section_iterator section_begin() const override;
+  section_iterator section_end() const override;
+  uint8_t getBytesInAddress() const override;
+  StringRef getFileFormatName() const override;
+  Triple::ArchType getArch() const override;
+  SubtargetFeatures getFeatures() const override;
+  bool isRelocatableObject() const override;
+
+public:
+  XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC);
+
+  const XCOFFFileHeader *getFileHeader() const { return FileHdrPtr; }
+
+}; // XCOFFObjectFile
+
+} // namespace object
+} // namespace llvm
+#endif // LLVM_OBJECT_XCOFFOBJECTFILE_H

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

+//===----- XCOFFYAML.h - XCOFF YAMLIO implementation ------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares classes for handling the YAML representation of XCOFF.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_OBJECTYAML_XCOFFYAML_H
+#define LLVM_OBJECTYAML_XCOFFYAML_H
+
+#include "llvm/ObjectYAML/YAML.h"
+#include <cstdint>
+
+namespace llvm {
+
+namespace XCOFFYAML {
+
+struct FileHeader {
+  llvm::yaml::Hex16 Magic;
+  uint16_t NumberOfSections;
+  int32_t TimeStamp;
+  llvm::yaml::Hex32 SymbolTableOffset; // File offset to symbol table.
+  int32_t NumberOfSymTableEntries;
+  uint16_t AuxHeaderSize;
+  llvm::yaml::Hex16 Flags;
+};
+
+struct Object {
+  FileHeader Header;
+  Object();
+};
+} // namespace XCOFFYAML
+
+namespace yaml {
+
+template <> struct MappingTraits<XCOFFYAML::FileHeader> {
+  static void mapping(IO &IO, XCOFFYAML::FileHeader &H);
+};
+
+template <> struct MappingTraits<XCOFFYAML::Object> {
+  static void mapping(IO &IO, XCOFFYAML::Object &Obj);
+};
+
+} // namespace yaml
+} // namespace llvm
+#endif // LLVM_OBJECTYAML_XCOFFYAML_H

llvm/lib/BinaryFormat/Magic.cpp

if (Magic.size() >= sizeof(COFF::WinResMagic) &&
       return file_magic::windows_resource;
     // 0x0000 = COFF unknown machine type
     if (Magic[1] == 0)
       return file_magic::coff_object;
     if (startswith(Magic, "\0asm"))
       return file_magic::wasm_object;
     break;
   }
+
+  case 0x01:
+    // XCOFF format
+    if (startswith(Magic, "\x01\xDF"))
+      return file_magic::xcoff_object_32;
+    break;
+
   case 0xDE: // 0x0B17C0DE = BC wraper
     if (startswith(Magic, "\xDE\xC0\x17\x0B"))
       return file_magic::bitcode;
     break;
   case 'B':
     if (startswith(Magic, "BC\xC0\xDE"))
       return file_magic::bitcode;
     break;

llvm/lib/Object/Binary.cpp

Expected<std::unique_ptr<Binary>> object::createBinary(MemoryBufferRef Buffer,
   case file_magic::macho_bundle:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::macho_dsym_companion:
   case file_magic::macho_kext_bundle:
   case file_magic::coff_object:
   case file_magic::coff_import_library:
   case file_magic::pecoff_executable:
   case file_magic::bitcode:
+  case file_magic::xcoff_object_32:
   case file_magic::wasm_object:
     return ObjectFile::createSymbolicFile(Buffer, Type, Context);
   case file_magic::macho_universal_binary:
     return MachOUniversalBinary::create(Buffer);
   case file_magic::windows_resource:
     return WindowsResource::createWindowsResource(Buffer);
   case file_magic::pdb:
     // PDB does not support the Binary interface.

llvm/lib/Object/CMakeLists.txt

add_llvm_library(LLVMObject
   ModuleSymbolTable.cpp
   Object.cpp
   ObjectFile.cpp
   RecordStreamer.cpp
   SymbolicFile.cpp
   SymbolSize.cpp
   WasmObjectFile.cpp
   WindowsResource.cpp
+  XCOFFObjectFile.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object
 
   DEPENDS
   intrinsics_gen
   llvm_vcsrevision_h
   )

llvm/lib/Object/ObjectFile.cpp

ObjectFile::createObjectFile(MemoryBufferRef Object, file_magic Type) {
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::macho_dsym_companion:
   case file_magic::macho_kext_bundle:
     return createMachOObjectFile(Object);
   case file_magic::coff_object:
   case file_magic::coff_import_library:
   case file_magic::pecoff_executable:
     return createCOFFObjectFile(Object);
+  case file_magic::xcoff_object_32:
+    return createXCOFFObjectFile(Object);
   case file_magic::wasm_object:
     return createWasmObjectFile(Object);
   }
   llvm_unreachable("Unexpected Object File Type");
 }
 
 Expected<OwningBinary<ObjectFile>>
 ObjectFile::createObjectFile(StringRef ObjectPath) {

llvm/lib/Object/SymbolicFile.cpp

SymbolicFile::createSymbolicFile(MemoryBufferRef Object, file_magic Type,
   case file_magic::macho_preload_executable:
   case file_magic::macho_dynamically_linked_shared_lib:
   case file_magic::macho_dynamic_linker:
   case file_magic::macho_bundle:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::macho_dsym_companion:
   case file_magic::macho_kext_bundle:
   case file_magic::pecoff_executable:
+  case file_magic::xcoff_object_32:
   case file_magic::wasm_object:
     return ObjectFile::createObjectFile(Object, Type);
   case file_magic::coff_import_library:
     return std::unique_ptr<SymbolicFile>(new COFFImportFile(Object));
   case file_magic::elf_relocatable:
   case file_magic::macho_object:
   case file_magic::coff_object: {
     Expected<std::unique_ptr<ObjectFile>> Obj =

llvm/lib/Object/XCOFFObjectFile.cpp

+//===--- XCOFFObjectFile.cpp - XCOFF object file implementation -----------===//
+//
+// 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 file defines the XCOFFObjectFile class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/XCOFFObjectFile.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MathExtras.h"
+#include <cstddef>
+#include <cstring>
+
+namespace llvm {
+namespace object {
+
+// Sets Obj unless any bytes in [addr, addr + size) fall outsize of m.
+// Returns unexpected_eof on error.
+template <typename T>
+static std::error_code getObject(const T *&Obj, MemoryBufferRef M,
+                                 const void *Ptr,
+                                 const uint64_t Size = sizeof(T)) {
+  uintptr_t Addr = uintptr_t(Ptr);
+  if (std::error_code EC = Binary::checkOffset(M, Addr, Size))
+    return EC;
+  Obj = reinterpret_cast<const T *>(Addr);
+  return std::error_code();
+}
+
+void XCOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
+  llvm_unreachable("Not yet implemented!");
+  return;
+}
+
+Expected<StringRef> XCOFFObjectFile::getSymbolName(DataRefImpl Symb) const {
+  StringRef Result;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+Expected<uint64_t> XCOFFObjectFile::getSymbolAddress(DataRefImpl Symb) const {
+  uint64_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+uint64_t XCOFFObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
+  uint64_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+uint64_t XCOFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
+  uint64_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+Expected<SymbolRef::Type>
+XCOFFObjectFile::getSymbolType(DataRefImpl Symb) const {
+  llvm_unreachable("Not yet implemented!");
+  return SymbolRef::ST_Other;
+}
+
+Expected<section_iterator>
+XCOFFObjectFile::getSymbolSection(DataRefImpl Symb) const {
+  llvm_unreachable("Not yet implemented!");
+  return section_iterator(SectionRef());
+}
+
+void XCOFFObjectFile::moveSectionNext(DataRefImpl &Sec) const {
+  llvm_unreachable("Not yet implemented!");
+  return;
+}
+
+std::error_code XCOFFObjectFile::getSectionName(DataRefImpl Sec,
+                                                StringRef &Res) const {
+  llvm_unreachable("Not yet implemented!");
+  return std::error_code();
+}
+
+uint64_t XCOFFObjectFile::getSectionAddress(DataRefImpl Sec) const {
+  uint64_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+uint64_t XCOFFObjectFile::getSectionIndex(DataRefImpl Sec) const {
+  uint64_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+uint64_t XCOFFObjectFile::getSectionSize(DataRefImpl Sec) const {
+  uint64_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+std::error_code XCOFFObjectFile::getSectionContents(DataRefImpl Sec,
+                                                    StringRef &Res) const {
+  llvm_unreachable("Not yet implemented!");
+  return std::error_code();
+}
+
+uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
+  uint64_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+bool XCOFFObjectFile::isSectionCompressed(DataRefImpl Sec) const {
+  bool ret = false;
+  llvm_unreachable("Not yet implemented!");
+  return ret;
+}
+
+bool XCOFFObjectFile::isSectionText(DataRefImpl Sec) const {
+  bool ret = false;
+  llvm_unreachable("Not yet implemented!");
+  return ret;
+}
+
+bool XCOFFObjectFile::isSectionData(DataRefImpl Sec) const {
+  bool ret = false;
+  llvm_unreachable("Not yet implemented!");
+  return ret;
+}
+
+bool XCOFFObjectFile::isSectionBSS(DataRefImpl Sec) const {
+  bool ret = false;
+  llvm_unreachable("Not yet implemented!");
+  return ret;
+}
+
+bool XCOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const {
+  bool ret = false;
+  llvm_unreachable("Not yet implemented!");
+  return ret;
+}
+
+relocation_iterator XCOFFObjectFile::section_rel_begin(DataRefImpl Sec) const {
+  llvm_unreachable("Not yet implemented!");
+  return relocation_iterator(RelocationRef());
+}
+
+relocation_iterator XCOFFObjectFile::section_rel_end(DataRefImpl Sec) const {
+  llvm_unreachable("Not yet implemented!");
+  return relocation_iterator(RelocationRef());
+}
+
+void XCOFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const { 
+  llvm_unreachable("Not yet implemented!");
+  return;
+}
+
+uint64_t XCOFFObjectFile::getRelocationOffset(DataRefImpl Rel) const {
+  llvm_unreachable("Not yet implemented!");
+  uint64_t Result = 0;
+  return Result;
+}
+
+symbol_iterator XCOFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
+  llvm_unreachable("Not yet implemented!");
+  return symbol_iterator(SymbolRef());
+}
+
+uint64_t XCOFFObjectFile::getRelocationType(DataRefImpl Rel) const {
+  llvm_unreachable("Not yet implemented!");
+  uint64_t Result = 0;
+  return Result;
+}
+
+void XCOFFObjectFile::getRelocationTypeName(
+    DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
+  llvm_unreachable("Not yet implemented!");
+  return;
+}
+
+uint32_t XCOFFObjectFile::getSymbolFlags(DataRefImpl Symb) const {
+  uint32_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+basic_symbol_iterator XCOFFObjectFile::symbol_begin() const {
+  llvm_unreachable("Not yet implemented!");
+  return basic_symbol_iterator(SymbolRef());
+}
+
+basic_symbol_iterator XCOFFObjectFile::symbol_end() const {
+  llvm_unreachable("Not yet implemented!");
+  return basic_symbol_iterator(SymbolRef());
+}
+
+section_iterator XCOFFObjectFile::section_begin() const {
+  llvm_unreachable("Not yet implemented!");
+  return section_iterator(SectionRef());
+}
+
+section_iterator XCOFFObjectFile::section_end() const {
+  llvm_unreachable("Not yet implemented!");
+  return section_iterator(SectionRef());
+}
+
+uint8_t XCOFFObjectFile::getBytesInAddress() const {
+  uint8_t Result = 0;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+StringRef XCOFFObjectFile::getFileFormatName() const {
+  llvm_unreachable("Not yet implemented!");
+  return "";
+}
+
+Triple::ArchType XCOFFObjectFile::getArch() const {
+  llvm_unreachable("Not yet implemented!");
+  return Triple::UnknownArch;
+}
+
+SubtargetFeatures XCOFFObjectFile::getFeatures() const {
+  llvm_unreachable("Not yet implemented!");
+  return SubtargetFeatures();
+}
+
+bool XCOFFObjectFile::isRelocatableObject() const {
+  bool Result = false;
+  llvm_unreachable("Not yet implemented!");
+  return Result;
+}
+
+XCOFFObjectFile::XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
+    : ObjectFile(Binary::ID_XCOFF32, Object) {
+  
+  // Current location within the file.
+  uint64_t CurPtr = 0;
+
+  if ((EC = getObject(FileHdrPtr, Data, base() + CurPtr)))
+    return;
+}
+
+Expected<std::unique_ptr<ObjectFile>>
+ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object) {
+  StringRef Data = Object.getBuffer();
+  file_magic Type = identify_magic(Data);
+  std::error_code EC;
+  std::unique_ptr<ObjectFile> Ret;
+
+  if (Type == file_magic::xcoff_object_32) {
+    Ret.reset(new XCOFFObjectFile(Object, EC));
+  } else {
+    llvm_unreachable("Encountered an unexpected binary file type!");
+  }
+
+  if (EC)
+    return errorCodeToError(EC);
+  return std::move(Ret);
+}
+
+} // namespace object
+} // namespace llvm

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
   WasmYAML.cpp
+  XCOFFYAML.cpp
   YAML.cpp
   )

llvm/lib/ObjectYAML/XCOFFYAML.cpp

+//===-- XCOFFYAML.cpp - XCOFF YAMLIO implementation -------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines classes for handling the YAML representation of XCOFF.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ObjectYAML/XCOFFYAML.h"
+#include "llvm/ObjectYAML/YAML.h"
+#include "llvm/Support/YAMLTraits.h"
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+
+namespace XCOFFYAML {
+
+Object::Object() { memset(&Header, 0, sizeof(Header)); }
+
+} // namespace XCOFFYAML
+
+namespace yaml {
+
+void MappingTraits<XCOFFYAML::FileHeader>::mapping(
+    IO &IO, XCOFFYAML::FileHeader &FileHdr) {
+  IO.mapRequired("MagicNumber", FileHdr.Magic);
+  IO.mapRequired("NumberOfSections", FileHdr.NumberOfSections);
+  IO.mapRequired("CreationTime", FileHdr.TimeStamp);
+  IO.mapRequired("OffsetToSymbolTable", FileHdr.SymbolTableOffset);
+  IO.mapRequired("EntriesInSymbolTable", FileHdr.NumberOfSymTableEntries);
+  IO.mapRequired("AuxiliaryHeaderSize", FileHdr.AuxHeaderSize);
+  IO.mapRequired("Flags", FileHdr.Flags);
+}
+
+void MappingTraits<XCOFFYAML::Object>::mapping(IO &IO, XCOFFYAML::Object &Obj) {
+  IO.mapTag("!XCOFF", true);
+  IO.mapRequired("FileHeader", Obj.Header);
+}
+
+} // namespace yaml
+} // namespace llvm

llvm/test/tools/obj2yaml/aix_xcoff.test

+# RUN: obj2yaml %S/Inputs/aix_xcoff.o | FileCheck %s
+# Test that we can parse the XCOFF object file correctly.
+# CHECK: --- !XCOFF
+# CHECK-NEXT: FileHeader: 
+# CHECK-NEXT: MagicNumber:     0x01DF
+# CHECK-NEXT: NumberOfSections: 2
+# CHECK-NEXT: CreationTime:    1548692020
+# CHECK-NEXT: OffsetToSymbolTable: 0x00000108
+# CHECK-NEXT: EntriesInSymbolTable: 18
+# CHECK-NEXT: AuxiliaryHeaderSize: 0
+# CHECK-NEXT: Flags:           0x0000

llvm/test/tools/obj2yaml/aix_xcoff_truncated_file_header.test

+# RUN: not obj2yaml %S/Inputs/aix_xcoff_truncated_file_header.o 2>&1 | FileCheck %s 
+# CHECK: The end of the file was unexpectedly encountered

llvm/tools/obj2yaml/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
   DebugInfoCodeView
   DebugInfoDWARF
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_tool(obj2yaml
   obj2yaml.cpp
   coff2yaml.cpp
   dwarf2yaml.cpp
   elf2yaml.cpp
   macho2yaml.cpp
+  xcoff2yaml.cpp
   wasm2yaml.cpp
   Error.cpp
   )

llvm/tools/obj2yaml/obj2yaml.h

 //===------ utils/obj2yaml.hpp - obj2yaml conversion tool -------*- 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
 //
 // This file declares some helper routines, and also the format-specific
 // writers. To add a new format, add the declaration here, and, in a separate
 // source file, implement it.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_OBJ2YAML_OBJ2YAML_H
 #define LLVM_TOOLS_OBJ2YAML_OBJ2YAML_H
 
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 std::error_code coff2yaml(llvm::raw_ostream &Out,
                           const llvm::object::COFFObjectFile &Obj);
 std::error_code elf2yaml(llvm::raw_ostream &Out,
                          const llvm::object::ObjectFile &Obj);
 std::error_code macho2yaml(llvm::raw_ostream &Out,
                            const llvm::object::Binary &Obj);
+std::error_code xcoff2yaml(llvm::raw_ostream &Out,
+                           const llvm::object::XCOFFObjectFile &Obj);
 std::error_code wasm2yaml(llvm::raw_ostream &Out,
                           const llvm::object::WasmObjectFile &Obj);
 
 // Forward decls for dwarf2yaml
 namespace llvm {
 class DWARFContext;
 namespace DWARFYAML {
 struct Data;
 }
 }
 
 std::error_code dwarf2yaml(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 
 #endif

llvm/tools/obj2yaml/obj2yaml.cpp

 #include "llvm/Support/InitLLVM.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 static std::error_code dumpObject(const ObjectFile &Obj) {
   if (Obj.isCOFF())
     return coff2yaml(outs(), cast<COFFObjectFile>(Obj));
+
+  if (Obj.isXCOFF())
+    return xcoff2yaml(outs(), cast<XCOFFObjectFile>(Obj));
+
   if (Obj.isELF())
     return elf2yaml(outs(), Obj);
   if (Obj.isWasm())
     return wasm2yaml(outs(), cast<WasmObjectFile>(Obj));
 
   return obj2yaml_error::unsupported_obj_file_format;
 }
 

llvm/tools/obj2yaml/xcoff2yaml.cpp

+//===------ xcoff2yaml.cpp - XCOFF YAMLIO implementation --------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "obj2yaml.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+#include "llvm/ObjectYAML/XCOFFYAML.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace llvm;
+using namespace llvm::object;
+namespace {
+
+class XCOFFDumper {
+  const object::XCOFFObjectFile &Obj;
+  XCOFFYAML::Object YAMLObj;
+  void dumpHeader();
+
+public:
+  XCOFFDumper(const object::XCOFFObjectFile &obj);
+  XCOFFYAML::Object &getYAMLObj() { return YAMLObj; }
+};
+} // namespace
+
+XCOFFDumper::XCOFFDumper(const object::XCOFFObjectFile &obj) : Obj(obj) {
+  dumpHeader();
+}
+
+void XCOFFDumper::dumpHeader() {
+  const XCOFFFileHeader *FileHdrPtr = Obj.getFileHeader();
+
+  YAMLObj.Header.Magic = FileHdrPtr->Magic;
+  YAMLObj.Header.NumberOfSections = FileHdrPtr->NumberOfSections;
+  YAMLObj.Header.TimeStamp = FileHdrPtr->TimeStamp;
+  YAMLObj.Header.SymbolTableOffset = FileHdrPtr->SymbolTableOffset;
+  YAMLObj.Header.NumberOfSymTableEntries = FileHdrPtr->NumberOfSymTableEntries;
+  YAMLObj.Header.AuxHeaderSize = FileHdrPtr->AuxHeaderSize;
+  YAMLObj.Header.Flags = FileHdrPtr->Flags;
+}
+
+std::error_code xcoff2yaml(raw_ostream &Out,
+                           const object::XCOFFObjectFile &Obj) {
+  XCOFFDumper Dumper(Obj);
+  yaml::Output Yout(Out);
+  Yout << Dumper.getYAMLObj();
+
+  return std::error_code();
+}