[Object][XCOFF] Add support for 64-bit file header and section header dumping.

[sfertile]

Summary

Adds a readobj dumper for 32-bit and 64-bit section header tables, and extend support for the file-header dumping to include 64-bit object files.

[DiggerLin]

llvm/include/llvm/Object/XCOFFObjectFile.h

240–244

I prefer to keep as uint16_t getFlags() const { return FileHdrPtr->Flags; };

llvm/lib/Object/XCOFFObjectFile.cpp

126

there are assert(!is64Bit() && "Symbol table support not implemented for 64-bit."); in the toSymbolEntry() , I do not think we need assert(!is64Bit() && "Symbol table support not implemented for 64-bit."); here.

132

ditto

182

ditto

482

it looks the flag as

support::big32_t Flags

in the XCOFFObjectFile.h

uint32_t XCOFFObjectFile::getSectionFlags(DataRefImpl Sec) const
should be int32_t XCOFFObjectFile::getSectionFlags(DataRefImpl Sec) const

496

if is64Bit(). it should return here.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

145

do you want to try to use W.printEnum to output Sec.Flags, it will be more readable

148

do we need to print relocation here ?

151

ditto

154

ditto

[MaskRay]

llvm/lib/Object/XCOFFObjectFile.cpp

49

getWithOffset does not seem useful: it just does a plus operation.

67

You may use Offset >= getSectionHeaderSize() * getNumberOfSections() instead.

84

I think inline reinterpret_cast may be clearer, then the viewAs helper can be deleted.

129

return; is redundant.

359–378

Consider making XCOFFObjectFile a class template.

See ELFObjectFile<ELFT> as an example, then you may avoid various is64Bit() dispatching in this file.

473

warning: using the result of an assignment as a condition without parentheses [-Wparentheses]

I remember I said in the initial check-in of this file: lib/Object code is moving away from std::error_code, ErrorOr and errorCodeToError. Error Expected etc should be used instead.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

240–244

We can't because of the underlying type depends on if its a 64-bit object or a 32-bit object, do you mean you would prefer if

return is64Bit() ? fileHeader64()->Flags : fileHeader32()->Flags;

was inline here?

llvm/lib/Object/XCOFFObjectFile.cpp

126

In the spirit of trying to keep this patch to a minimum I only implemented section headers and file-header support. I put defensive assert to indicate that I hadn't evaluated any of the symbol related interfaces for 64-bit. While this would technically work for 64-bit, that is only because the 64-bit symbol table entrey happens to also be 18 bytes of data. Casting a 64-bit symbol table entry to an XCOFFSymbolEntry is still wrong as they have different layouts.

132

Again, the 64-bit and 32-bit symbol table entries have different layouts, this function AFAICT would not work for a 64-bit Symbol table entry. (Its String table offset member is at offset 8 instead of offset 4).

482

Good catch, updated.

496

is64Bit() has already returned on line 495.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

145

Updated, thats a good suggestion.

148

When that is supported, yes.

151

Yep, once dumping symbols from objdump is supported.

154

same.

[sfertile]

Addressed first round of review comments.

• Fix getSectionFlags return value to be signed.
• Print the section flags as its symbolic value.

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

49

The function helps the code be more self-documenting about the intended semantics and is much more greppable than raw arithmetic. This allows pointer arithmetic to be properly performed in pointer space. Although not all such arithmetic is done in pointer space currently, that does not mean that we shouldn't keep the instances where they are.

84

The viewAs helper is not new to this patch. Additionally, it saves on verbosity and noise that is distracting. Familiarity with viewAs is not difficult to attain.

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

496

thanks.

[sfertile]

Address further comments:

• Simplified the address checking in 'checkSectionAddress'
• Removed unneeded asserts. As Digger pointed out, an symbol related function that casts a DataRefImpl.p to a symbol table entry already asserts in toSymbolEntry.

Still outstanding: cleaning up of the error handling in the constructor.

[sfertile]

llvm/lib/Object/XCOFFObjectFile.cpp

126

Sorry Digger you are correct, I don't need to add an assert in any of the interfaces that cast a DataRefImpl to a SymbolEntry as the helper fucntion asserts. Updated.

473

Attempting to clean this up next.

[sfertile]

Converted the way parsing the binary is done to not need an error_code out argument in the constructor. Creates a bare bones object file, then attempts to parse the expected structures out of the memory buffer. Trying to match the style ELF used.

[hubert.reinterpretcast]

llvm/include/llvm/Object/XCOFFObjectFile.h

162

Typo: "Constuctor [sic]".

Suggestion:
Constructor and "create" factory function. The constructor is only a thin wrapper around the base constructor. The "create" function fills out the XCOFF-specific information and performs the error checking along the way.

168

I would suggest adding an empty line before this comment block. Also, break the sentence just before "returns" (where the comma is).

173

s/freind/friend/;

211

If the extra empty line is meant to signify that the interface functions below are not inherited from a base class, then perhaps a comment would work better.

213

This is a public function, so there should be an assertion regarding use when is64Bit() is true.

234

Add an empty line before this. Also, missing "as" before "an index".

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

200–201

Remove the space before the return type.

399

What does SI mean?

507

Use either "string table's size" or "string-table size".
Typo: s/as string/a string/;

[hubert.reinterpretcast]

This patch seems to have suffered from scope creep. The replacement of error_code has led to a considerable shifting around of the code that makes it more difficult to review the other part of the patch. Since it has already happened, I guess we will push through; however, I believe this sort of situation should be avoided.

llvm/lib/Object/XCOFFObjectFile.cpp

508

Just practising my theoretical-overflow avoidance:

assert(Obj->Data.getBufferSize() >= Offset);
if (Obj->Data.getBufferSize() - Offset < 4)

Or use a helper function:

if (auto EC = Binary::checkOffset(Obj->Data, Offset, 4))

513

Use getObject.

518

s/StingTablePtr/StringTablePtr/g;

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

532

const auto *Base.

533

MemoryBufferRef Data.

547

s/Pase/Parse/;

Suggestion:
Parse the section header table if it is present.

547

The XCOFFObjectFile constructor will assert as appropriate without this assert here.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

154

STYP_OVRFLO/_OVERFLOW_MARKER handling TODO here.

160

Please test STYP_DWARF. It looks like the handling of DWARF section subtypes is missing. At the least, Sec.Flags & 0xffU might help.

164

These should be report_fatal_error.

llvm/tools/obj2yaml/xcoff2yaml.cpp

44

s/suported/supported/;

[sfertile]

• Lots of tweaks to comments and whitespace.
  • Added assertion to 'getPointerToSymbolTable`
  • Changed name of local variable in getSymbolSectionName to be more descriptive.
  • Use checkOffset and getObject'in parseStringTable.
  • Changed unreachables to report_fatal_error in 'printSectionHeaders`.
  • Added TODO where overflow checking eventually needs to be done.
  • Added comment about DWARF subsection types, & limited section flag printing to the section type flags.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

162

Updated with suggested comment.

llvm/lib/Object/XCOFFObjectFile.cpp

399

No idea :S. Updated to a more appropriate name.

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

509

I would much prefer to perform the addition before the cast.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

155

s/STYP_OVRFLO/_OVERFLOW_MARKER/;

There's no _OVERFLOW_MARKER in the code currently, so we might want to add an appropriate named constant.

[sfertile]

• Perform address arithmetic on const char* before casting to a uintptr_t.
  • Fixup comment. NumberOfX == STYP_OVRFLO doesn't make sense as STYP_OVRFLO is a section type. _OVERFLOW_MARKER is the name of the constant representing the overflow marker value.

[sfertile]

llvm/lib/Object/XCOFFObjectFile.cpp

509

Good catch, updated.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

155

Updated the comment.

I didn't add the named constant yet because its not used in the code anywhere and I though expressing how there are 32-bit and 64-bit values for _OVERFLOW_MARKER with the 64-bit value (IIUC) not actually representing overflow difficult to do without the overflow handling code.

[hubert.reinterpretcast]

LGTM.

llvm/include/llvm/BinaryFormat/Magic.h

enum Impl {
     macho_universal_binary,                   ///< Mach-O universal binary
     minidump,                                 ///< Windows minidump file
     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
+    xcoff_object_64,     ///< 64-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_Minidump,
 
     ID_WinRes, // Windows resource (.res) file.
 
     // Object and children.
     ID_StartObjects,
     ID_COFF,
+
     ID_XCOFF32, // AIX XCOFF 32-bit
+    ID_XCOFF64, // AIX XCOFF 64-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 isXCOFF() const { return TypeID == ID_XCOFF32 || TypeID == ID_XCOFF64; }
 
   bool isWasm() const { return TypeID == ID_Wasm; }
 
   bool isCOFFImportFile() const {
     return TypeID == ID_COFFImportFile;
   }
 
   bool isIR() const {

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);
+  createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType);
 
   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);

llvm/include/llvm/Object/XCOFFObjectFile.h

 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <system_error>
 
 namespace llvm {
 namespace object {
 
-struct XCOFFFileHeader {
+struct XCOFFFileHeader32 {
   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;
 };
 
-struct XCOFFSectionHeader {
+struct XCOFFFileHeader64 {
+  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::ubig64_t SymbolTableOffset; // File offset to symbol table.
+  support::ubig16_t AuxHeaderSize;
+  support::ubig16_t Flags;
+  support::ubig32_t NumberOfSymTableEntries;
+};
+
+struct XCOFFSectionHeader32 {
   char Name[XCOFF::SectionNameSize];
   support::ubig32_t PhysicalAddress;
   support::ubig32_t VirtualAddress;
   support::ubig32_t SectionSize;
   support::ubig32_t FileOffsetToRawData;
   support::ubig32_t FileOffsetToRelocationInfo;
   support::ubig32_t FileOffsetToLineNumberInfo;
   support::ubig16_t NumberOfRelocations;
   support::ubig16_t NumberOfLineNumbers;
   support::big32_t Flags;
+
+  StringRef getName() const;
+};
+
+struct XCOFFSectionHeader64 {
+  char Name[XCOFF::SectionNameSize];
+  support::ubig64_t PhysicalAddress;
+  support::ubig64_t VirtualAddress;
+  support::ubig64_t SectionSize;
+  support::big64_t FileOffsetToRawData;
+  support::big64_t FileOffsetToRelocationInfo;
+  support::big64_t FileOffsetToLineNumberInfo;
+  support::ubig32_t NumberOfRelocations;
+  support::ubig32_t NumberOfLineNumbers;
+  support::big32_t Flags;
+  char Padding[4];
+
+  StringRef getName() const;
 };
 
 struct XCOFFSymbolEntry {
   enum { NAME_IN_STR_TBL_MAGIC = 0x0 };
   typedef struct {
     support::big32_t Magic; // Zero indicates name in string table.
     support::ubig32_t Offset;
   } NameInStrTblType;

 
 struct XCOFFStringTable {
   uint32_t Size;
   const char *Data;
 };
 
 class XCOFFObjectFile : public ObjectFile {
 private:
-  const XCOFFFileHeader *FileHdrPtr = nullptr;
-  const XCOFFSectionHeader *SectionHdrTablePtr = nullptr;
+  const void *FileHeader = nullptr;
+  const void *SectionHeaderTable = nullptr;
+
   const XCOFFSymbolEntry *SymbolTblPtr = nullptr;
   XCOFFStringTable StringTable = {0, nullptr};
 
+  const XCOFFFileHeader32 *fileHeader32() const;
+  const XCOFFFileHeader64 *fileHeader64() const;
+
+  const XCOFFSectionHeader32 *sectionHeaderTable32() const;
+  const XCOFFSectionHeader64 *sectionHeaderTable64() const;
+
   size_t getFileHeaderSize() const;
   size_t getSectionHeaderSize() const;
 
-  const XCOFFSectionHeader *toSection(DataRefImpl Ref) const;
+  const XCOFFSectionHeader32 *toSection32(DataRefImpl Ref) const;
+  const XCOFFSectionHeader64 *toSection64(DataRefImpl Ref) const;
+  void checkSectionAddress(uintptr_t Addr, uintptr_t TableAddr) const;
+  uintptr_t getSectionHeaderTableAddress() const;
+
+  // This returns a pointer to the start of the storage for the name field of
+  // the 32-bit or 64-bit SectionHeader struct. This string is *not* necessarily
+  // null-terminated.
+  const char *getSectionNameInternal(DataRefImpl Sec) const;
+
+  int32_t getSectionFlags(DataRefImpl Sec) const;
+
   static bool isReservedSectionNumber(int16_t SectionNumber);
-  std::error_code getSectionByNum(int16_t Num,
-                                  const XCOFFSectionHeader *&Result) const;
+  Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 
 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;
   Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
   uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
   Expected<ArrayRef<uint8_t>>
   getSectionContents(DataRefImpl Sec) const override;
public:
   section_iterator section_end() const override;
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
   Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override;
   Expected<uint64_t> getStartAddress() const override;
   bool isRelocatableObject() const override;
 
-  XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC);
+  XCOFFObjectFile(unsigned Type, MemoryBufferRef Object, std::error_code &EC);
+
+  bool is64Bit() const;
 
-  const XCOFFFileHeader *getFileHeader() const { return FileHdrPtr; }
   const XCOFFSymbolEntry *getPointerToSymbolTable() const {
     return SymbolTblPtr;
   }
 
   Expected<StringRef>
   getSymbolSectionName(const XCOFFSymbolEntry *SymEntPtr) const;
 
   const XCOFFSymbolEntry *toSymbolEntry(DataRefImpl Ref) const;
+
+  // File header related interfaces.
   uint16_t getMagic() const;
   uint16_t getNumberOfSections() const;
   int32_t getTimeStamp() const;
-  uint32_t getSymbolTableOffset() const;
 
-  // Returns the value as encoded in the object file.
-  // Negative values are reserved for future use.
-  int32_t getRawNumberOfSymbolTableEntries() const;
+  // Symbol table offset and entry count are handled differently between
+  // XCOFF32 and XCOFF64.
+  uint32_t getSymbolTableOffset32() const;
+  uint64_t getSymbolTableOffset64() const;
+
+  // Note that this value is signed and might return a negative value. Negative
+  // values are reserved for future use.
+  int32_t getRawNumberOfSymbolTableEntries32() const;
+  // The sanitized value appropriate to use an index into the symbol table.
+  uint32_t getLogicalNumberOfSymbolTableEntries32() const;
+
+  uint32_t getNumberOfSymbolTableEntries64() const;
 
-  // Returns a sanitized value, useable as an index into the symbol table.
-  uint32_t getLogicalNumberOfSymbolTableEntries() const;
   uint16_t getOptionalHeaderSize() const;
-  uint16_t getFlags() const { return FileHdrPtr->Flags; };
+  uint16_t getFlags() const;
+
+  // Section header table related interfaces.
+  ArrayRef<XCOFFSectionHeader32> sections32() const;
+  ArrayRef<XCOFFSectionHeader64> sections64() const;
 }; // XCOFFObjectFile
 
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_XCOFFOBJECTFILE_H

llvm/lib/BinaryFormat/Magic.cpp

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;
+    if (startswith(Magic, "\x01\xF7"))
+      return file_magic::xcoff_object_64;
     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"))

llvm/lib/Object/Binary.cpp

Expected<std::unique_ptr<Binary>> object::createBinary(MemoryBufferRef Buffer,
   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::xcoff_object_64:
   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/ObjectFile.cpp

ObjectFile::createObjectFile(MemoryBufferRef Object, file_magic Type) {
   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);
+    return createXCOFFObjectFile(Object, Binary::ID_XCOFF32);
+  case file_magic::xcoff_object_64:
+    return createXCOFFObjectFile(Object, Binary::ID_XCOFF64);
   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_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::xcoff_object_64:
   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

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstddef>
 #include <cstring>
 
 namespace llvm {
 namespace object {
 
-enum { XCOFF32FileHeaderSize = 20 };
-static_assert(sizeof(XCOFFFileHeader) == XCOFF32FileHeaderSize,
-              "Wrong size for XCOFF file header.");
-
 // Sets EC and returns false if there is less than 'Size' bytes left in the
 // buffer at 'Offset'.
 static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Offset,
                       uint64_t Size) {
   if (M.getBufferSize() < Offset + Size) {
     EC = object_error::unexpected_eof;
     return false;
   }
   return true;
 }
 
 // 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();
 }
 
+static uintptr_t getWithOffset(uintptr_t Base, ptrdiff_t Offset) {
+  return reinterpret_cast<uintptr_t>(reinterpret_cast<const char *>(Base) +
+                                     Offset);
+}
+
 template <typename T> static const T *viewAs(uintptr_t in) {
   return reinterpret_cast<const T *>(in);
 }
 
 static StringRef generateStringRef(const char *Name, uint64_t Size) {
   auto NulCharPtr = static_cast<const char *>(memchr(Name, '\0', Size));
   return NulCharPtr ? StringRef(Name, NulCharPtr - Name)
                     : StringRef(Name, Size);
 }
 
-const XCOFFSectionHeader *XCOFFObjectFile::toSection(DataRefImpl Ref) const {
-  auto Sec = viewAs<XCOFFSectionHeader>(Ref.p);
-#ifndef NDEBUG
-  if (Sec < SectionHdrTablePtr ||
-      Sec >= (SectionHdrTablePtr + getNumberOfSections()))
+void XCOFFObjectFile::checkSectionAddress(uintptr_t Addr,
+                                          uintptr_t TableAddress) const {
+  if (Addr < TableAddress)
+    report_fatal_error("Section header outside of section header table.");
+
+  uintptr_t Offset = Addr - TableAddress;
+  if (Offset >= getSectionHeaderSize() * getNumberOfSections())
     report_fatal_error("Section header outside of section header table.");
 
-  uintptr_t Offset = uintptr_t(Sec) - uintptr_t(SectionHdrTablePtr);
   if (Offset % getSectionHeaderSize() != 0)
     report_fatal_error(
         "Section header pointer does not point to a valid section header.");
+}
+
+const XCOFFSectionHeader32 *
+XCOFFObjectFile::toSection32(DataRefImpl Ref) const {
+  assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
+#ifndef NDEBUG
+  checkSectionAddress(Ref.p, getSectionHeaderTableAddress());
 #endif
-  return Sec;
+  return viewAs<XCOFFSectionHeader32>(Ref.p);
+}
+
+const XCOFFSectionHeader64 *
+XCOFFObjectFile::toSection64(DataRefImpl Ref) const {
+  assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
+#ifndef NDEBUG
+  checkSectionAddress(Ref.p, getSectionHeaderTableAddress());
+#endif
+  return viewAs<XCOFFSectionHeader64>(Ref.p);
 }
 
 const XCOFFSymbolEntry *XCOFFObjectFile::toSymbolEntry(DataRefImpl Ref) const {
+  assert(!is64Bit() && "Symbol table support not implemented for 64-bit.");
   assert(Ref.p != 0 && "Symbol table pointer can not be nullptr!");
   auto SymEntPtr = viewAs<XCOFFSymbolEntry>(Ref.p);
   return SymEntPtr;
 }
 
-// The next 2 functions are not exactly necessary yet, but they are useful to
-// abstract over the size difference between XCOFF32 and XCOFF64 structure
-// definitions.
-size_t XCOFFObjectFile::getFileHeaderSize() const {
-  return sizeof(XCOFFFileHeader);
+const XCOFFFileHeader32 *XCOFFObjectFile::fileHeader32() const {
+  assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
+  return static_cast<const XCOFFFileHeader32 *>(FileHeader);
 }
 
-size_t XCOFFObjectFile::getSectionHeaderSize() const {
-  return sizeof(XCOFFSectionHeader);
+const XCOFFFileHeader64 *XCOFFObjectFile::fileHeader64() const {
+  assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
+  return static_cast<const XCOFFFileHeader64 *>(FileHeader);
+}
+
+const XCOFFSectionHeader32 *
+XCOFFObjectFile::sectionHeaderTable32() const {
+  assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
+  return static_cast<const XCOFFSectionHeader32 *>(SectionHeaderTable);
 }
 
-uint16_t XCOFFObjectFile::getMagic() const { return FileHdrPtr->Magic; }
+const XCOFFSectionHeader64 *
+XCOFFObjectFile::sectionHeaderTable64() const {
+  assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
+  return static_cast<const XCOFFSectionHeader64 *>(SectionHeaderTable);
+}
 
 void XCOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
   const XCOFFSymbolEntry *SymEntPtr = toSymbolEntry(Symb);
-
   SymEntPtr += SymEntPtr->NumberOfAuxEntries + 1;
   Symb.p = reinterpret_cast<uintptr_t>(SymEntPtr);
 }
 
 Expected<StringRef> XCOFFObjectFile::getSymbolName(DataRefImpl Symb) const {
   const XCOFFSymbolEntry *SymEntPtr = toSymbolEntry(Symb);
 
   if (SymEntPtr->NameInStrTbl.Magic != XCOFFSymbolEntry::NAME_IN_STR_TBL_MAGIC)
     return generateStringRef(SymEntPtr->SymbolName, XCOFF::SymbolNameSize);
 
   // A storage class value with the high-order bit on indicates that the name is
   // a symbolic debugger stabstring.
   if (SymEntPtr->StorageClass & 0x80)
     return StringRef("Unimplemented Debug Name");

 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 {
   const XCOFFSymbolEntry *SymEntPtr = toSymbolEntry(Symb);
   int16_t SectNum = SymEntPtr->SectionNumber;
 
   if (isReservedSectionNumber(SectNum))
     return section_end();
 
-  const XCOFFSectionHeader *Sec;
-  if (std::error_code EC = getSectionByNum(SectNum, Sec))
-    return errorCodeToError(EC);
+  Expected<DataRefImpl> ExpSec = getSectionByNum(SectNum);
+  if (!ExpSec)
+    return ExpSec.takeError();
 
-  DataRefImpl SecDRI;
-  SecDRI.p = reinterpret_cast<uintptr_t>(Sec);
-
-  return section_iterator(SectionRef(SecDRI, this));
+  return section_iterator(SectionRef(ExpSec.get(), this));
 }
 
 void XCOFFObjectFile::moveSectionNext(DataRefImpl &Sec) const {
   const char *Ptr = reinterpret_cast<const char *>(Sec.p);
   Sec.p = reinterpret_cast<uintptr_t>(Ptr + getSectionHeaderSize());
 }
 
  Expected<StringRef> XCOFFObjectFile::getSectionName(DataRefImpl Sec) const {
-  const char *Name = toSection(Sec)->Name;
-  auto NulCharPtr =
-      static_cast<const char *>(memchr(Name, '\0', XCOFF::SectionNameSize));
-  return NulCharPtr ? StringRef(Name, NulCharPtr - Name)
-                    : StringRef(Name, XCOFF::SectionNameSize);
+  return generateStringRef(getSectionNameInternal(Sec), XCOFF::SectionNameSize);
 }
 
 uint64_t XCOFFObjectFile::getSectionAddress(DataRefImpl Sec) const {
-  return toSection(Sec)->VirtualAddress;
+  return is64Bit() ? toSection64(Sec)->VirtualAddress
+                   : toSection32(Sec)->VirtualAddress;
 }
 
 uint64_t XCOFFObjectFile::getSectionIndex(DataRefImpl Sec) const {
   // Section numbers in XCOFF are numbered beginning at 1. A section number of
   // zero is used to indicate that a symbol is being imported or is undefined.
-  return toSection(Sec) - SectionHdrTablePtr + 1;
+  if (is64Bit())
+    return toSection64(Sec) - sectionHeaderTable64() + 1;
+  else
+    return toSection32(Sec) - sectionHeaderTable32() + 1;
 }
 
 uint64_t XCOFFObjectFile::getSectionSize(DataRefImpl Sec) const {
-  return toSection(Sec)->SectionSize;
+  return is64Bit() ? toSection64(Sec)->SectionSize
+                   : toSection32(Sec)->SectionSize;
 }
 
 Expected<ArrayRef<uint8_t>>
 XCOFFObjectFile::getSectionContents(DataRefImpl Sec) const {
   llvm_unreachable("Not yet implemented!");
 }
 
 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 Result = false;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 
 bool XCOFFObjectFile::isSectionText(DataRefImpl Sec) const {
-  return toSection(Sec)->Flags & XCOFF::STYP_TEXT;
+  return getSectionFlags(Sec) & XCOFF::STYP_TEXT;
 }
 
 bool XCOFFObjectFile::isSectionData(DataRefImpl Sec) const {
-  unsigned Flags = toSection(Sec)->Flags;
+  uint32_t Flags = getSectionFlags(Sec);
   return Flags & (XCOFF::STYP_DATA | XCOFF::STYP_TDATA);
 }
 
 bool XCOFFObjectFile::isSectionBSS(DataRefImpl Sec) const {
-  unsigned Flags = toSection(Sec)->Flags;
+  uint32_t Flags = getSectionFlags(Sec);
   return Flags & (XCOFF::STYP_BSS | XCOFF::STYP_TBSS);
 }
 
 bool XCOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const {
   bool Result = false;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }

 
 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 {
+  assert(!is64Bit() && "64-bit support not implemented yet.");
   DataRefImpl SymDRI;
   SymDRI.p = reinterpret_cast<uintptr_t>(SymbolTblPtr);
   return basic_symbol_iterator(SymbolRef(SymDRI, this));
 }
 
 basic_symbol_iterator XCOFFObjectFile::symbol_end() const {
+  assert(!is64Bit() && "64-bit support not implemented yet.");
   DataRefImpl SymDRI;
   SymDRI.p = reinterpret_cast<uintptr_t>(
-      SymbolTblPtr + getLogicalNumberOfSymbolTableEntries());
+      SymbolTblPtr + getLogicalNumberOfSymbolTableEntries32());
   return basic_symbol_iterator(SymbolRef(SymDRI, this));
 }
 
 section_iterator XCOFFObjectFile::section_begin() const {
   DataRefImpl DRI;
-  DRI.p = reinterpret_cast<uintptr_t>(SectionHdrTablePtr);
+  DRI.p = getSectionHeaderTableAddress();
   return section_iterator(SectionRef(DRI, this));
 }
 
 section_iterator XCOFFObjectFile::section_end() const {
   DataRefImpl DRI;
-  DRI.p =
-      reinterpret_cast<uintptr_t>(SectionHdrTablePtr + getNumberOfSections());
+  DRI.p = getWithOffset(getSectionHeaderTableAddress(),
+                        getNumberOfSections() * getSectionHeaderSize());
   return section_iterator(SectionRef(DRI, this));
 }
 
-uint8_t XCOFFObjectFile::getBytesInAddress() const {
-  // Only support 32-bit object files for now ...
-  assert(getFileHeaderSize() == XCOFF32FileHeaderSize);
-  return 4;
-}
+uint8_t XCOFFObjectFile::getBytesInAddress() const { return is64Bit() ? 8 : 4; }
 
 StringRef XCOFFObjectFile::getFileFormatName() const {
-  assert(getFileHeaderSize() == XCOFF32FileHeaderSize);
-  return "aixcoff-rs6000";
+  return is64Bit() ? "aix5coff64-rs6000" : "aixcoff-rs6000";
 }
 
 Triple::ArchType XCOFFObjectFile::getArch() const {
-  assert(getFileHeaderSize() == XCOFF32FileHeaderSize);
-  return Triple::ppc;
+  return is64Bit() ? Triple::ppc64 : Triple::ppc;
 }
 
 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;
 }
 
 Expected<uint64_t> XCOFFObjectFile::getStartAddress() const {
   // TODO FIXME Should get from auxiliary_header->o_entry when support for the
   // auxiliary_header is added.
   return 0;
 }
 
-std::error_code
-XCOFFObjectFile::getSectionByNum(int16_t Num,
-                                 const XCOFFSectionHeader *&Result) const {
-  if (Num > 0 && static_cast<uint16_t>(Num) <= getNumberOfSections()) {
-    Result = SectionHdrTablePtr + (Num - 1);
-    return std::error_code();
-  }
+size_t XCOFFObjectFile::getFileHeaderSize() const {
+  return is64Bit() ? sizeof(XCOFFFileHeader64) : sizeof(XCOFFFileHeader32);
 
-  return object_error::invalid_section_index;
+size_t XCOFFObjectFile::getSectionHeaderSize() const {
+  return is64Bit() ? sizeof(XCOFFSectionHeader64) :
+                     sizeof(XCOFFSectionHeader32);
+}
+
+bool XCOFFObjectFile::is64Bit() const {
+  return Binary::ID_XCOFF64 == getType();
+}
+
+uint16_t XCOFFObjectFile::getMagic() const {
+  return is64Bit() ? fileHeader64()->Magic : fileHeader32()->Magic;
+}
+
+Expected<DataRefImpl> XCOFFObjectFile::getSectionByNum(int16_t Num) const {
+  if (Num <= 0 || Num > getNumberOfSections())
+    return errorCodeToError(object_error::invalid_section_index);
+
+  DataRefImpl DRI;
+  DRI.p = getWithOffset(getSectionHeaderTableAddress(),
+                        getSectionHeaderSize() * (Num - 1));
+  return DRI;
 }
 
 Expected<StringRef>
 XCOFFObjectFile::getSymbolSectionName(const XCOFFSymbolEntry *SymEntPtr) const {
+  assert(!is64Bit() && "Symbol table support not implemented for 64-bit.");
   int16_t SectionNum = SymEntPtr->SectionNumber;
 
   switch (SectionNum) {
   case XCOFF::N_DEBUG:
     return "N_DEBUG";
   case XCOFF::N_ABS:
     return "N_ABS";
   case XCOFF::N_UNDEF:
     return "N_UNDEF";
-  default: {
-    const XCOFFSectionHeader *SectHeaderPtr;
-    std::error_code EC;
-    if ((EC = getSectionByNum(SectionNum, SectHeaderPtr)))
-      return errorCodeToError(EC);
-    else
-      return generateStringRef(SectHeaderPtr->Name, XCOFF::SectionNameSize);
-  }
+  default:
+    Expected<DataRefImpl> SI = getSectionByNum(SectionNum);
+    if (SI)
+      return generateStringRef(getSectionNameInternal(SI.get()),
+                               XCOFF::SectionNameSize);
+    return SI.takeError();
   }
 }
 
 bool XCOFFObjectFile::isReservedSectionNumber(int16_t SectionNumber) {
   return (SectionNumber <= 0 && SectionNumber >= -2);
 }
 
 uint16_t XCOFFObjectFile::getNumberOfSections() const {
-  return FileHdrPtr->NumberOfSections;
+  return is64Bit() ? fileHeader64()->NumberOfSections
+                   : fileHeader32()->NumberOfSections;
 }
 
-int32_t XCOFFObjectFile::getTimeStamp() const { return FileHdrPtr->TimeStamp; }
+int32_t XCOFFObjectFile::getTimeStamp() const {
+  return is64Bit() ? fileHeader64()->TimeStamp : fileHeader32()->TimeStamp;
+}
+
+uint16_t XCOFFObjectFile::getOptionalHeaderSize() const {
+  return is64Bit() ? fileHeader64()->AuxHeaderSize
+                   : fileHeader32()->AuxHeaderSize;
+}
 
-uint32_t XCOFFObjectFile::getSymbolTableOffset() const {
-  return FileHdrPtr->SymbolTableOffset;
+uint32_t XCOFFObjectFile::getSymbolTableOffset32() const {
+  return fileHeader32()->SymbolTableOffset;
 }
 
-int32_t XCOFFObjectFile::getRawNumberOfSymbolTableEntries() const {
-  return FileHdrPtr->NumberOfSymTableEntries;
+int32_t XCOFFObjectFile::getRawNumberOfSymbolTableEntries32() const {
+  // As far as symbol table size is concerned, if this field is negative it is
+  // to be treated as a 0. However since this field is also used for printing we
+  // don't want to truncate any negative values.
+  return fileHeader32()->NumberOfSymTableEntries;
 }
 
-uint32_t XCOFFObjectFile::getLogicalNumberOfSymbolTableEntries() const {
-  return (FileHdrPtr->NumberOfSymTableEntries >= 0
-              ? FileHdrPtr->NumberOfSymTableEntries
+uint32_t XCOFFObjectFile::getLogicalNumberOfSymbolTableEntries32() const {
+  return (fileHeader32()->NumberOfSymTableEntries >= 0
+              ? fileHeader32()->NumberOfSymTableEntries
               : 0);
 }
 
-uint16_t XCOFFObjectFile::getOptionalHeaderSize() const {
-  return FileHdrPtr->AuxHeaderSize;
+uint64_t XCOFFObjectFile::getSymbolTableOffset64() const {
+  return fileHeader64()->SymbolTableOffset;
+}
+
+uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries64() const {
+  return fileHeader64()->NumberOfSymTableEntries;
+}
+
+uint16_t XCOFFObjectFile::getFlags() const {
+  return is64Bit() ? fileHeader64()->Flags : fileHeader32()->Flags;
+}
+
+const char *XCOFFObjectFile::getSectionNameInternal(DataRefImpl Sec) const {
+  return is64Bit() ? toSection64(Sec)->Name : toSection32(Sec)->Name;
 }
 
-XCOFFObjectFile::XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
-    : ObjectFile(Binary::ID_XCOFF32, Object) {
+uintptr_t XCOFFObjectFile::getSectionHeaderTableAddress() const {
+  return reinterpret_cast<uintptr_t>(SectionHeaderTable);
+}
+
+int32_t XCOFFObjectFile::getSectionFlags(DataRefImpl Sec) const {
+  return is64Bit() ? toSection64(Sec)->Flags : toSection32(Sec)->Flags;
+}
+
+XCOFFObjectFile::XCOFFObjectFile(unsigned int Type, MemoryBufferRef Object,
+                                 std::error_code &EC)
+    : ObjectFile(Type, Object) {
+  assert(Type == Binary::ID_XCOFF32 || Type == Binary::ID_XCOFF64);
 
   // Current location within the file.
   uint64_t CurPtr = 0;
-
-  if ((EC = getObject(FileHdrPtr, Data, base() + CurPtr)))
+  if (EC = getObject(FileHeader, Data, base() + CurPtr, getFileHeaderSize()))
     return;
 
   CurPtr += getFileHeaderSize();
   // TODO FIXME we don't have support for an optional header yet, so just skip
   // past it.
-  CurPtr += FileHdrPtr->AuxHeaderSize;
+  CurPtr += getOptionalHeaderSize();
 
   if (getNumberOfSections() != 0) {
-    if ((EC = getObject(SectionHdrTablePtr, Data, base() + CurPtr,
+    if ((EC = getObject(SectionHeaderTable, Data, base() + CurPtr,
                         getNumberOfSections() * getSectionHeaderSize())))
       return;
   }
 
-  if (getLogicalNumberOfSymbolTableEntries() == 0)
+  // Support for the symbol table and string table parsing is limited to 32-bit
+  // object files for now.
+  if (is64Bit())
+    return;
+
+  if (getLogicalNumberOfSymbolTableEntries32() == 0)
     return;
 
   // Get pointer to the symbol table.
-  CurPtr = FileHdrPtr->SymbolTableOffset;
+  CurPtr = fileHeader32()->SymbolTableOffset;
   uint64_t SymbolTableSize = (uint64_t)(sizeof(XCOFFSymbolEntry)) *
-                             getLogicalNumberOfSymbolTableEntries();
+                             getLogicalNumberOfSymbolTableEntries32();
 
   if ((EC = getObject(SymbolTblPtr, Data, base() + CurPtr, SymbolTableSize)))
     return;
 
   // Move pointer to the string table.
   CurPtr += SymbolTableSize;
 
   if (CurPtr + 4 > Data.getBufferSize())
     return;
 
   StringTable.Size = support::endian::read32be(base() + CurPtr);
 
   if (StringTable.Size <= 4)
     return;
 
   // Check for whether the String table has the size indicated by length
   // field
   if (!checkSize(Data, EC, CurPtr, StringTable.Size))
     return;
 
   StringTable.Data = reinterpret_cast<const char *>(base() + CurPtr);
   if (StringTable.Data[StringTable.Size - 1] != '\0') {
     EC = object_error::string_table_non_null_end;
     return;
   }
 }
 
+ArrayRef<XCOFFSectionHeader64> XCOFFObjectFile::sections64() const {
+  assert(is64Bit() && "64-bit interface called for non 64-bit file.");
+  const XCOFFSectionHeader64 *TablePtr = sectionHeaderTable64();
+  return ArrayRef<XCOFFSectionHeader64>(
+      TablePtr, TablePtr + getNumberOfSections());
+}
+
+ArrayRef<XCOFFSectionHeader32> XCOFFObjectFile::sections32() const {
+  assert(!is64Bit() && "32-bit interface called for non 32-bit file.");
+  const XCOFFSectionHeader32 *TablePtr = sectionHeaderTable32();
+  return ArrayRef<XCOFFSectionHeader32>(
+      TablePtr, TablePtr + getNumberOfSections());
+}
+
 Expected<std::unique_ptr<ObjectFile>>
-ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object) {
-  StringRef Data = Object.getBuffer();
-  file_magic Type = identify_magic(Data);
+ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType) {
   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!");
-  }
+  assert((FileType == Binary::ID_XCOFF32 || FileType == Binary::ID_XCOFF64) &&
+         "Non-XCOFF file type passed to createXCOFFObjectFile!");
+
+  Ret.reset(new XCOFFObjectFile(FileType, Object, EC));
 
   if (EC)
     return errorCodeToError(EC);
   return std::move(Ret);
 }
 
+StringRef XCOFFSectionHeader32::getName() const {
+  return generateStringRef(Name, XCOFF::SectionNameSize);
+}
+
+StringRef XCOFFSectionHeader64::getName() const {
+  return generateStringRef(Name, XCOFF::SectionNameSize);
+}
+
 } // namespace object
 } // namespace llvm

llvm/test/tools/llvm-readobj/xcoff-basic.test

 # RUN: llvm-readobj --file-header %p/Inputs/xcoff-basic.o | \
 # RUN: FileCheck --check-prefix=FILEHEADER %s
+#
+# RUN: llvm-readobj --file-header %p/Inputs/xcoff-basic-64.o | \
+# RUN: FileCheck --check-prefix=FILEHEADER64 %s
 
 # RUN: llvm-readobj --file-header %p/Inputs/xcoff-basic-neg-time.o | \
 # RUN: FileCheck --check-prefix=NEGTIME %s
 
 # RUN: llvm-readobj --file-header %p/Inputs/xcoff-basic-neg-sym-count.o | \
 # RUN: FileCheck --check-prefix=NEGSYMCOUNT %s
 
 # FILEHEADER:     File: {{.*}}xcoff-basic.o
 # FILEHEADER-NEXT: Format: aixcoff-rs6000
 # FILEHEADER-NEXT: Arch: powerpc
 # FILEHEADER-NEXT: AddressSize: 32bit
 # FILEHEADER-NEXT: FileHeader {
 # FILEHEADER-NEXT:   Magic: 0x1DF
 # FILEHEADER-NEXT:   NumberOfSections: 6
 # FILEHEADER-NEXT:   TimeStamp: 2019-03-12T14:04:43Z (0x5C87BC7B)
 # FILEHEADER-NEXT:   SymbolTableOffset: 0x52E
 # FILEHEADER-NEXT:   SymbolTableEntries: 120
 # FILEHEADER-NEXT:   OptionalHeaderSize: 0x1C
 # FILEHEADER-NEXT:   Flags: 0x0
 # FILEHEADER-NEXT: }
 
+# FILEHEADER64:     File: {{.*}}xcoff-basic-64.o
+# FILEHEADER64-NEXT:  Format: aix5coff64-rs6000
+# FILEHEADER64-NEXT:  Arch: powerpc64
+# FILEHEADER64-NEXT:  AddressSize: 64bit
+# FILEHEADER64-NEXT:  FileHeader {
+# FILEHEADER64-NEXT:    Magic: 0x1F7
+# FILEHEADER64-NEXT:    NumberOfSections: 5
+# FILEHEADER64-NEXT:    TimeStamp: 2019-03-18T20:03:47Z (0x5C8FF9A3)
+# FILEHEADER64-NEXT:    SymbolTableOffset: 0x54C
+# FILEHEADER64-NEXT:    SymbolTableEntries: 58
+# FILEHEADER64-NEXT:    OptionalHeaderSize: 0x0
+# FILEHEADER64-NEXT:    Flags: 0x0
+# FILEHEADER64-NEXT:  }
+
 # NEGTIME:     File: {{.*}}xcoff-basic-neg-time.o
 # NEGTIME-NEXT:  Format: aixcoff-rs6000
 # NEGTIME-NEXT:  Arch: powerpc
 # NEGTIME-NEXT:  AddressSize: 32bit
 # NEGTIME-NEXT:  FileHeader {
 # NEGTIME-NEXT:    Magic: 0x1DF
 # NEGTIME-NEXT:    NumberOfSections: 6
 # NEGTIME-NEXT:    TimeStamp: Reserved Value (0xDC87BC7B)

llvm/test/tools/llvm-readobj/xcoff-sections.test

+# RUN: llvm-readobj --section-headers %p/Inputs/xcoff-basic.o | \
+# RUN: FileCheck --check-prefix=SEC32 %s
+
+# RUN: llvm-readobj --section-headers %p/Inputs/xcoff-basic-64.o | \
+# RUN: FileCheck --check-prefix=SEC64 %s
+
+# SEC32:     File: {{.*}}xcoff-basic.o
+# SEC32-NEXT:  Format: aixcoff-rs6000
+# SEC32-NEXT:  Arch: powerpc
+# SEC32-NEXT:  AddressSize: 32bit
+# SEC32-NEXT:  Sections [
+# SEC32-NEXT:    Section {
+# SEC32-NEXT:      Index: 1
+# SEC32-NEXT:      Name: .text
+# SEC32-NEXT:      PhysicalAddress: 0x0
+# SEC32-NEXT:      VirtualAddress: 0x0
+# SEC32-NEXT:      Size: 0x100
+# SEC32-NEXT:      RawDataOffset: 0x200
+# SEC32-NEXT:      RelocationPointer: 0x3D8
+# SEC32-NEXT:      LineNumberPointer: 0x4E6
+# SEC32-NEXT:      NumberOfRelocations: 8
+# SEC32-NEXT:      NumberOfLineNumbers: 12
+# SEC32-NEXT:      Type: STYP_TEXT (0x20)
+# SEC32-NEXT:    }
+# SEC32-NEXT:    Section {
+# SEC32-NEXT:      Index: 2
+# SEC32-NEXT:      Name: .data
+# SEC32-NEXT:      PhysicalAddress: 0x100
+# SEC32-NEXT:      VirtualAddress: 0x100
+# SEC32-NEXT:      Size: 0x68
+# SEC32-NEXT:      RawDataOffset: 0x300
+# SEC32-NEXT:      RelocationPointer: 0x428
+# SEC32-NEXT:      LineNumberPointer: 0x0
+# SEC32-NEXT:      NumberOfRelocations: 19
+# SEC32-NEXT:      NumberOfLineNumbers: 0
+# SEC32-NEXT:      Type: STYP_DATA (0x40)
+# SEC32-NEXT:    }
+# SEC32-NEXT:    Section {
+# SEC32-NEXT:      Index: 3
+# SEC32-NEXT:      Name: .bss
+# SEC32-NEXT:      PhysicalAddress: 0x168
+# SEC32-NEXT:      VirtualAddress: 0x168
+# SEC32-NEXT:      Size: 0x4
+# SEC32-NEXT:      RawDataOffset: 0x0
+# SEC32-NEXT:      RelocationPointer: 0x0
+# SEC32-NEXT:      LineNumberPointer: 0x0
+# SEC32-NEXT:      NumberOfRelocations: 0
+# SEC32-NEXT:      NumberOfLineNumbers: 0
+# SEC32-NEXT:      Type: STYP_BSS (0x80)
+# SEC32-NEXT:    }
+# SEC32-NEXT:    Section {
+# SEC32-NEXT:      Index: 4
+# SEC32-NEXT:      Name: .tdata
+# SEC32-NEXT:      PhysicalAddress: 0x0
+# SEC32-NEXT:      VirtualAddress: 0x0
+# SEC32-NEXT:      Size: 0x4
+# SEC32-NEXT:      RawDataOffset: 0x368
+# SEC32-NEXT:      RelocationPointer: 0x47A
+# SEC32-NEXT:      LineNumberPointer: 0x0
+# SEC32-NEXT:      NumberOfRelocations: 0
+# SEC32-NEXT:      NumberOfLineNumbers: 0
+# SEC32-NEXT:      Type: STYP_TDATA (0x400)
+# SEC32-NEXT:    }
+# SEC32-NEXT:    Section {
+# SEC32-NEXT:      Index: 5
+# SEC32-NEXT:      Name: .tbss
+# SEC32-NEXT:      PhysicalAddress: 0x4
+# SEC32-NEXT:      VirtualAddress: 0x4
+# SEC32-NEXT:      Size: 0x8
+# SEC32-NEXT:      RawDataOffset: 0x0
+# SEC32-NEXT:      RelocationPointer: 0x0
+# SEC32-NEXT:      LineNumberPointer: 0x0
+# SEC32-NEXT:      NumberOfRelocations: 0
+# SEC32-NEXT:      NumberOfLineNumbers: 0
+# SEC32-NEXT:      Type: STYP_TBSS (0x800)
+# SEC32-NEXT:    }
+# SEC32-NEXT:    Section {
+# SEC32-NEXT:      Index: 6
+# SEC32-NEXT:      Name: .debug
+# SEC32-NEXT:      PhysicalAddress: 0x0
+# SEC32-NEXT:      VirtualAddress: 0x0
+# SEC32-NEXT:      Size: 0x6C
+# SEC32-NEXT:      RawDataOffset: 0x36C
+# SEC32-NEXT:      RelocationPointer: 0x0
+# SEC32-NEXT:      LineNumberPointer: 0x0
+# SEC32-NEXT:      NumberOfRelocations: 0
+# SEC32-NEXT:      NumberOfLineNumbers: 0
+# SEC32-NEXT:      Type: STYP_DEBUG (0x2000)
+# SEC32-NEXT:    }
+# SEC32-NEXT:  ]
+
+
+# SEC64:     File: {{.*}}xcoff-basic-64.o
+# SEC64-NEXT:  Format: aix5coff64-rs6000
+# SEC64-NEXT:  Arch: powerpc64
+# SEC64-NEXT:  AddressSize: 64bit
+# SEC64-NEXT:  Sections [
+# SEC64-NEXT:    Section {
+# SEC64-NEXT:      Index: 1
+# SEC64-NEXT:      Name: .text
+# SEC64-NEXT:      PhysicalAddress: 0x0
+# SEC64-NEXT:      VirtualAddress: 0x0
+# SEC64-NEXT:      Size: 0x100
+# SEC64-NEXT:      RawDataOffset: 0x200
+# SEC64-NEXT:      RelocationPointer: 0x3C4
+# SEC64-NEXT:      LineNumberPointer: 0x0
+# SEC64-NEXT:      NumberOfRelocations: 9
+# SEC64-NEXT:      NumberOfLineNumbers: 0
+# SEC64-NEXT:      Type: STYP_TEXT (0x20)
+# SEC64-NEXT:    }
+# SEC64-NEXT:    Section {
+# SEC64-NEXT:      Index: 2
+# SEC64-NEXT:      Name: .data
+# SEC64-NEXT:      PhysicalAddress: 0x100
+# SEC64-NEXT:      VirtualAddress: 0x100
+# SEC64-NEXT:      Size: 0xC0
+# SEC64-NEXT:      RawDataOffset: 0x300
+# SEC64-NEXT:      RelocationPointer: 0x442
+# SEC64-NEXT:      LineNumberPointer: 0x0
+# SEC64-NEXT:      NumberOfRelocations: 19
+# SEC64-NEXT:      NumberOfLineNumbers: 0
+# SEC64-NEXT:      Type: STYP_DATA (0x40)
+# SEC64-NEXT:    }
+# SEC64-NEXT:    Section {
+# SEC64-NEXT:      Index: 3
+# SEC64-NEXT:      Name: .bss
+# SEC64-NEXT:      PhysicalAddress: 0x1C0
+# SEC64-NEXT:      VirtualAddress: 0x1C0
+# SEC64-NEXT:      Size: 0x8
+# SEC64-NEXT:      RawDataOffset: 0x0
+# SEC64-NEXT:      RelocationPointer: 0x0
+# SEC64-NEXT:      LineNumberPointer: 0x0
+# SEC64-NEXT:      NumberOfRelocations: 0
+# SEC64-NEXT:      NumberOfLineNumbers: 0
+# SEC64-NEXT:      Type: STYP_BSS (0x80)
+# SEC64-NEXT:    }
+# SEC64-NEXT:    Section {
+# SEC64-NEXT:      Index: 4
+# SEC64-NEXT:      Name: .tdata
+# SEC64-NEXT:      PhysicalAddress: 0x0
+# SEC64-NEXT:      VirtualAddress: 0x0
+# SEC64-NEXT:      Size: 0x4
+# SEC64-NEXT:      RawDataOffset: 0x3C0
+# SEC64-NEXT:      RelocationPointer: 0x54C
+# SEC64-NEXT:      LineNumberPointer: 0x0
+# SEC64-NEXT:      NumberOfRelocations: 0
+# SEC64-NEXT:      NumberOfLineNumbers: 0
+# SEC64-NEXT:      Type: STYP_TDATA (0x400)
+# SEC64-NEXT:    }
+# SEC64-NEXT:    Section {
+# SEC64-NEXT:      Index: 5
+# SEC64-NEXT:      Name: .tbss
+# SEC64-NEXT:      PhysicalAddress: 0x4
+# SEC64-NEXT:      VirtualAddress: 0x4
+# SEC64-NEXT:      Size: 0x8
+# SEC64-NEXT:      RawDataOffset: 0x0
+# SEC64-NEXT:      RelocationPointer: 0x0
+# SEC64-NEXT:      LineNumberPointer: 0x0
+# SEC64-NEXT:      NumberOfRelocations: 0
+# SEC64-NEXT:      NumberOfLineNumbers: 0
+# SEC64-NEXT:      Type: STYP_TBSS (0x800)
+# SEC64-NEXT:    }
+# SEC64-NEXT:  ]
+

llvm/tools/llvm-readobj/XCOFFDumper.cpp

public:
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
   void printNeededLibraries() override;
 
 private:
+  template <typename T> void printSectionHeaders(ArrayRef<T> Sections);
+
   const XCOFFObjectFile &Obj;
+
+  // Least significant 3 bits are reserved.
+  static constexpr unsigned SectionFlagsReservedMask = 0x7;
 };
 } // anonymous namespace
 
 void XCOFFDumper::printFileHeaders() {
   DictScope DS(W, "FileHeader");
   W.printHex("Magic", Obj.getMagic());
   W.printNumber("NumberOfSections", Obj.getNumberOfSections());
 
if (BytesWritten)
       W.printHex("TimeStamp", FormattedTime, TimeStamp);
     else
       W.printHex("Timestamp", TimeStamp);
   } else {
     W.printHex("TimeStamp", TimeStamp == 0 ? "None" : "Reserved Value",
                TimeStamp);
   }
 
-  W.printHex("SymbolTableOffset", Obj.getSymbolTableOffset());
-  int32_t SymTabEntries = Obj.getRawNumberOfSymbolTableEntries();
+  // The number of symbol table entries is an unsigned value in 64-bit objects
+  // and a signed value (with negative values being 'reserved') in 32-bit
+  // objects.
+  if (Obj.is64Bit()) {
+    W.printHex("SymbolTableOffset", Obj.getSymbolTableOffset64());
+    W.printNumber("SymbolTableEntries", Obj.getNumberOfSymbolTableEntries64());
+  } else {
+    W.printHex("SymbolTableOffset", Obj.getSymbolTableOffset32());
+    int32_t SymTabEntries = Obj.getRawNumberOfSymbolTableEntries32();
     if (SymTabEntries >= 0)
       W.printNumber("SymbolTableEntries", SymTabEntries);
     else
       W.printHex("SymbolTableEntries", "Reserved Value", SymTabEntries);
+  }
 
   W.printHex("OptionalHeaderSize", Obj.getOptionalHeaderSize());
   W.printHex("Flags", Obj.getFlags());
 
   // TODO FIXME Add support for the auxiliary header (if any) once
   // XCOFFObjectFile has the necessary support.
 }
 
 void XCOFFDumper::printSectionHeaders() {
-  llvm_unreachable("Unimplemented functionality for XCOFFDumper");
+  if (Obj.is64Bit())
+    printSectionHeaders(Obj.sections64());
+  else
+    printSectionHeaders(Obj.sections32());
 }
 
 void XCOFFDumper::printRelocations() {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
 
 void XCOFFDumper::printSymbols() {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");

 void XCOFFDumper::printStackMap() const {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
 
 void XCOFFDumper::printNeededLibraries() {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
 
+static const EnumEntry<XCOFF::SectionTypeFlags> SectionTypeFlagsNames[] = {
+#define ECase(X)                                                               \
+  { #X, XCOFF::X }
+    ECase(STYP_PAD),    ECase(STYP_DWARF), ECase(STYP_TEXT),
+    ECase(STYP_DATA),   ECase(STYP_BSS),   ECase(STYP_EXCEPT),
+    ECase(STYP_INFO),   ECase(STYP_TDATA), ECase(STYP_TBSS),
+    ECase(STYP_LOADER), ECase(STYP_DEBUG), ECase(STYP_TYPCHK),
+    ECase(STYP_OVRFLO)
+#undef ECase
+};
+
+template <typename T>
+void XCOFFDumper::printSectionHeaders(ArrayRef<T> Sections) {
+  ListScope Group(W, "Sections");
+
+  uint16_t Index = 1;
+  for (const T &Sec : Sections) {
+    DictScope SecDS(W, "Section");
+
+    W.printNumber("Index", Index++);
+    W.printString("Name", Sec.getName());
+
+    W.printHex("PhysicalAddress", Sec.PhysicalAddress);
+    W.printHex("VirtualAddress", Sec.VirtualAddress);
+    W.printHex("Size", Sec.SectionSize);
+    W.printHex("RawDataOffset", Sec.FileOffsetToRawData);
+    W.printHex("RelocationPointer", Sec.FileOffsetToRelocationInfo);
+    W.printHex("LineNumberPointer", Sec.FileOffsetToLineNumberInfo);
+    W.printNumber("NumberOfRelocations", Sec.NumberOfRelocations);
+    W.printNumber("NumberOfLineNumbers", Sec.NumberOfLineNumbers);
+
+    if (Sec.Flags & SectionFlagsReservedMask)
+      W.printHex("Flags", "Reserved", Sec.Flags);
+    else
+      W.printEnum("Type", Sec.Flags, makeArrayRef(SectionTypeFlagsNames));
+  }
+
+  if (opts::SectionRelocations)
+    llvm_unreachable("Dumping section relocations is unimplemented");
+
+  if (opts::SectionSymbols)
+    llvm_unreachable("Dumping symbols is unimplemented");
+
+  if (opts::SectionData)
+    llvm_unreachable("Dumping section data is unimplemented");
+}
+
 namespace llvm {
 std::error_code createXCOFFDumper(const object::ObjectFile *Obj,
                                   ScopedPrinter &Writer,
                                   std::unique_ptr<ObjDumper> &Result) {
   const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(Obj);
   if (!XObj)
     return readobj_error::unsupported_obj_file_format;
 
   Result.reset(new XCOFFDumper(*XObj, Writer));
   return readobj_error::success;
 }
 } // namespace llvm

llvm/tools/obj2yaml/xcoff2yaml.cpp

 public:
   XCOFFDumper(const object::XCOFFObjectFile &obj) : Obj(obj) {}
   std::error_code dump();
   XCOFFYAML::Object &getYAMLObj() { return YAMLObj; }
 };
 } // namespace
 
 std::error_code XCOFFDumper::dump() {
-  std::error_code EC;
   dumpHeader();
-  EC = dumpSymbols();
-  return EC;
+  return dumpSymbols();
 }
 
 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;
+  YAMLObj.Header.Magic = Obj.getMagic();
+  YAMLObj.Header.NumberOfSections = Obj.getNumberOfSections();
+  YAMLObj.Header.TimeStamp = Obj.getTimeStamp();
+
+  // TODO FIXME only dump 32 bit header for now.
+  if (Obj.is64Bit())
+    report_fatal_error("64-bit XCOFF files not suported yet.");
+  YAMLObj.Header.SymbolTableOffset = Obj.getSymbolTableOffset32();
+
+  YAMLObj.Header.NumberOfSymTableEntries =
+      Obj.getRawNumberOfSymbolTableEntries32();
+  YAMLObj.Header.AuxHeaderSize = Obj.getOptionalHeaderSize();
+  YAMLObj.Header.Flags = Obj.getFlags();
 }
 
 std::error_code XCOFFDumper::dumpSymbols() {
   std::vector<XCOFFYAML::Symbol> &Symbols = YAMLObj.Symbols;
 
   for (const SymbolRef &S : Obj.symbols()) {
     DataRefImpl SymbolDRI = S.getRawDataRefImpl();
     const XCOFFSymbolEntry *SymbolEntPtr = Obj.toSymbolEntry(SymbolDRI);