[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 ↗

(On Diff #206741)

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

llvm/lib/Object/XCOFFObjectFile.cpp

125 ↗

(On Diff #206741)

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.

134 ↗

(On Diff #206741)

ditto

186 ↗

(On Diff #206741)

ditto

467 ↗

(On Diff #206741)

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

501 ↗

(On Diff #206741)

if is64Bit(). it should return here.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

142 ↗

(On Diff #206741)

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

145 ↗

(On Diff #206741)

do we need to print relocation here ?

148 ↗

(On Diff #206741)

ditto

151 ↗

(On Diff #206741)

ditto

[MaskRay]

llvm/lib/Object/XCOFFObjectFile.cpp

49 ↗

(On Diff #206741)

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

67 ↗

(On Diff #206741)

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

83 ↗

(On Diff #206741)

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

130 ↗

(On Diff #206741)

return; is redundant.

364 ↗

(On Diff #206741)

Consider making XCOFFObjectFile a class template.

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

478 ↗

(On Diff #206741)

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 ↗

(On Diff #206741)

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

125 ↗

(On Diff #206741)

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.

134 ↗

(On Diff #206741)

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

467 ↗

(On Diff #206741)

Good catch, updated.

501 ↗

(On Diff #206741)

is64Bit() has already returned on line 495.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

142 ↗

(On Diff #206741)

Updated, thats a good suggestion.

145 ↗

(On Diff #206741)

When that is supported, yes.

148 ↗

(On Diff #206741)

Yep, once dumping symbols from objdump is supported.

151 ↗

(On Diff #206741)

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 ↗

(On Diff #206741)

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.

83 ↗

(On Diff #206741)

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

501 ↗

(On Diff #206741)

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

125 ↗

(On Diff #206741)

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.

478 ↗

(On Diff #206741)

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 ↗

(On Diff #207142)

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 ↗

(On Diff #207142)

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

173 ↗

(On Diff #207142)

s/freind/friend/;

223 ↗

(On Diff #207142)

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.

227 ↗

(On Diff #207142)

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

248 ↗

(On Diff #207142)

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

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

187 ↗

(On Diff #207142)

Remove the space before the return type.

386 ↗

(On Diff #207142)

What does SI mean?

475 ↗

(On Diff #207142)

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

476 ↗

(On Diff #207142)

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))

488 ↗

(On Diff #207142)

Use getObject.

492 ↗

(On Diff #207142)

s/StingTablePtr/StringTablePtr/g;

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

507 ↗

(On Diff #207142)

const auto *Base.

508 ↗

(On Diff #207142)

MemoryBufferRef Data.

522 ↗

(On Diff #207142)

s/Pase/Parse/;

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

564 ↗

(On Diff #207142)

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

llvm/tools/llvm-readobj/XCOFFDumper.cpp

154 ↗

(On Diff #207142)

STYP_OVRFLO/_OVERFLOW_MARKER handling TODO here.

160 ↗

(On Diff #207142)

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

164 ↗

(On Diff #207142)

These should be report_fatal_error.

llvm/tools/obj2yaml/xcoff2yaml.cpp

44 ↗

(On Diff #207142)

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 ↗

(On Diff #207142)

Updated with suggested comment.

llvm/lib/Object/XCOFFObjectFile.cpp

386 ↗

(On Diff #207142)

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

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

477 ↗

(On Diff #208078)

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

llvm/tools/llvm-readobj/XCOFFDumper.cpp

155 ↗

(On Diff #208078)

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

477 ↗

(On Diff #208078)

Good catch, updated.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

155 ↗

(On Diff #208078)

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/trunk/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/trunk/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/trunk/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/trunk/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;
+
+  // 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.
+  XCOFFObjectFile(unsigned Type, MemoryBufferRef Object);
+  static Expected<std::unique_ptr<XCOFFObjectFile>> create(unsigned Type,
+                                                           MemoryBufferRef MBR);
+
+  // Helper for parsing the StringTable. Returns an 'Error' if parsing failed
+  // and an XCOFFStringTable if parsing succeeded.
+  static Expected<XCOFFStringTable> parseStringTable(const XCOFFObjectFile *Obj,
+                                                     uint64_t Offset);
+
+  // Make a friend so it can call the private 'create' function.
+  friend Expected<std::unique_ptr<ObjectFile>>
+  ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType);
 
 public:
+  // Interface inherited from base classes.
   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;
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);
+  // Below here is the non-inherited interface.
+  bool is64Bit() const;
 
-  const XCOFFFileHeader *getFileHeader() const { return FileHdrPtr; }
   const XCOFFSymbolEntry *getPointerToSymbolTable() const {
+    assert(!is64Bit() && "Symbol table handling not supported yet.");
     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 as 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/trunk/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/trunk/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/trunk/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/trunk/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/trunk/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.
+// Checks that [Ptr, Ptr + Size) bytes fall inside the memory buffer
+// 'M'. Returns a pointer to the underlying object on success.
 template <typename T>
-static std::error_code getObject(const T *&Obj, MemoryBufferRef M,
-                                 const void *Ptr,
+static Expected<const T *> getObject(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();
+    return errorCodeToError(EC);
+  return reinterpret_cast<const T *>(Addr);
+}
+
+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)

 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);
-
-  DataRefImpl SecDRI;
-  SecDRI.p = reinterpret_cast<uintptr_t>(Sec);
+  Expected<DataRefImpl> ExpSec = getSectionByNum(SectNum);
+  if (!ExpSec)
+    return ExpSec.takeError();
 
-  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> SecRef = getSectionByNum(SectionNum);
+    if (SecRef)
+      return generateStringRef(getSectionNameInternal(SecRef.get()),
+                               XCOFF::SectionNameSize);
+    return SecRef.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;
 }
 
-XCOFFObjectFile::XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
-    : ObjectFile(Binary::ID_XCOFF32, Object) {
+uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries64() const {
+  return fileHeader64()->NumberOfSymTableEntries;
+}
 
-  // Current location within the file.
-  uint64_t CurPtr = 0;
+uint16_t XCOFFObjectFile::getFlags() const {
+  return is64Bit() ? fileHeader64()->Flags : fileHeader32()->Flags;
+}
 
-  if ((EC = getObject(FileHdrPtr, Data, base() + CurPtr)))
-    return;
+const char *XCOFFObjectFile::getSectionNameInternal(DataRefImpl Sec) const {
+  return is64Bit() ? toSection64(Sec)->Name : toSection32(Sec)->Name;
+}
 
-  CurPtr += getFileHeaderSize();
-  // TODO FIXME we don't have support for an optional header yet, so just skip
-  // past it.
-  CurPtr += FileHdrPtr->AuxHeaderSize;
+uintptr_t XCOFFObjectFile::getSectionHeaderTableAddress() const {
+  return reinterpret_cast<uintptr_t>(SectionHeaderTable);
+}
 
-  if (getNumberOfSections() != 0) {
-    if ((EC = getObject(SectionHdrTablePtr, Data, base() + CurPtr,
-                        getNumberOfSections() * getSectionHeaderSize())))
-      return;
-  }
+int32_t XCOFFObjectFile::getSectionFlags(DataRefImpl Sec) const {
+  return is64Bit() ? toSection64(Sec)->Flags : toSection32(Sec)->Flags;
 
-  if (getLogicalNumberOfSymbolTableEntries() == 0)
-    return;
+XCOFFObjectFile::XCOFFObjectFile(unsigned int Type, MemoryBufferRef Object)
+    : ObjectFile(Type, Object) {
+  assert(Type == Binary::ID_XCOFF32 || Type == Binary::ID_XCOFF64);
+}
 
-  // Get pointer to the symbol table.
-  CurPtr = FileHdrPtr->SymbolTableOffset;
-  uint64_t SymbolTableSize = (uint64_t)(sizeof(XCOFFSymbolEntry)) *
-                             getLogicalNumberOfSymbolTableEntries();
+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());
+}
 
-  if ((EC = getObject(SymbolTblPtr, Data, base() + CurPtr, SymbolTableSize)))
-    return;
+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());
+}
 
-  // Move pointer to the string table.
-  CurPtr += SymbolTableSize;
+Expected<XCOFFStringTable>
+XCOFFObjectFile::parseStringTable(const XCOFFObjectFile *Obj, uint64_t Offset) {
+  // If there is a string table, then the buffer must contain at least 4 bytes
+  // for the string table's size. Not having a string table is not an error.
+  if (auto EC = Binary::checkOffset(
+          Obj->Data, reinterpret_cast<uintptr_t>(Obj->base() + Offset), 4))
+    return XCOFFStringTable{0, nullptr};
 
-  if (CurPtr + 4 > Data.getBufferSize())
-    return;
+  // Read the size out of the buffer.
+  uint32_t Size = support::endian::read32be(Obj->base() + Offset);
 
-  StringTable.Size = support::endian::read32be(base() + CurPtr);
+  // If the size is less then 4, then the string table is just a size and no
+  // string data.
+  if (Size <= 4)
+    return XCOFFStringTable{4, nullptr};
 
-  if (StringTable.Size <= 4)
-    return;
+  auto StringTableOrErr =
+      getObject<char>(Obj->Data, Obj->base() + Offset, Size);
+  if (Error E = StringTableOrErr.takeError())
+    return std::move(E);
 
-  // Check for whether the String table has the size indicated by length
-  // field
-  if (!checkSize(Data, EC, CurPtr, StringTable.Size))
-    return;
+  const char *StringTablePtr = StringTableOrErr.get();
+  if (StringTablePtr[Size - 1] != '\0')
+    return errorCodeToError(object_error::string_table_non_null_end);
 
-  StringTable.Data = reinterpret_cast<const char *>(base() + CurPtr);
-  if (StringTable.Data[StringTable.Size - 1] != '\0') {
-    EC = object_error::string_table_non_null_end;
-    return;
-  }
+  return XCOFFStringTable{Size, StringTablePtr};
+
+Expected<std::unique_ptr<XCOFFObjectFile>>
+XCOFFObjectFile::create(unsigned Type, MemoryBufferRef MBR) {
+  // Can't use make_unique because of the private constructor.
+  std::unique_ptr<XCOFFObjectFile> Obj;
+  Obj.reset(new XCOFFObjectFile(Type, MBR));
+
+  uint64_t CurOffset = 0;
+  const auto *Base = Obj->base();
+  MemoryBufferRef Data = Obj->Data;
+
+  // Parse file header.
+  auto FileHeaderOrErr =
+      getObject<void>(Data, Base + CurOffset, Obj->getFileHeaderSize());
+  if (Error E = FileHeaderOrErr.takeError())
+    return std::move(E);
+  Obj->FileHeader = FileHeaderOrErr.get();
+
+  CurOffset += Obj->getFileHeaderSize();
+  // TODO FIXME we don't have support for an optional header yet, so just skip
+  // past it.
+  CurOffset += Obj->getOptionalHeaderSize();
+
+  // Parse the section header table if it is present.
+  if (Obj->getNumberOfSections()) {
+    auto SecHeadersOrErr = getObject<void>(Data, Base + CurOffset,
+                                           Obj->getNumberOfSections() *
+                                               Obj->getSectionHeaderSize());
+    if (Error E = SecHeadersOrErr.takeError())
+      return std::move(E);
+    Obj->SectionHeaderTable = SecHeadersOrErr.get();
+  }
+
+  // 64-bit object supports only file header and section headers for now.
+  if (Obj->is64Bit())
+    return std::move(Obj);
+
+  // If there is no symbol table we are done parsing the memory buffer.
+  if (Obj->getLogicalNumberOfSymbolTableEntries32() == 0)
+    return std::move(Obj);
+
+  // Parse symbol table.
+  CurOffset = Obj->fileHeader32()->SymbolTableOffset;
+  uint64_t SymbolTableSize = (uint64_t)(sizeof(XCOFFSymbolEntry)) *
+                             Obj->getLogicalNumberOfSymbolTableEntries32();
+  auto SymTableOrErr =
+      getObject<XCOFFSymbolEntry>(Data, Base + CurOffset, SymbolTableSize);
+  if (Error E = SymTableOrErr.takeError())
+    return std::move(E);
+  Obj->SymbolTblPtr = SymTableOrErr.get();
+  CurOffset += SymbolTableSize;
+
+  // Parse String table.
+  Expected<XCOFFStringTable> StringTableOrErr =
+      parseStringTable(Obj.get(), CurOffset);
+  if (Error E = StringTableOrErr.takeError())
+    return std::move(E);
+  Obj->StringTable = StringTableOrErr.get();
+
+  return std::move(Obj);
 }
 
 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!");
-  }
+ObjectFile::createXCOFFObjectFile(MemoryBufferRef MemBufRef,
+                                  unsigned FileType) {
+  return XCOFFObjectFile::create(FileType, MemBufRef);
 
-  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/trunk/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/trunk/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/trunk/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);
+
+    // TODO Need to add overflow handling when NumberOfX == _OVERFLOW_MARKER
+    // in 32-bit object files.
+    W.printNumber("NumberOfRelocations", Sec.NumberOfRelocations);
+    W.printNumber("NumberOfLineNumbers", Sec.NumberOfLineNumbers);
+
+    // The most significant 16-bits represent the DWARF section subtype. For
+    // now we just dump the section type flags.
+    uint16_t Flags = Sec.Flags & 0xffffu;
+    if (Flags & SectionFlagsReservedMask)
+      W.printHex("Flags", "Reserved", Flags);
+    else
+      W.printEnum("Type", Flags, makeArrayRef(SectionTypeFlagsNames));
+  }
+
+  if (opts::SectionRelocations)
+    report_fatal_error("Dumping section relocations is unimplemented");
+
+  if (opts::SectionSymbols)
+    report_fatal_error("Dumping symbols is unimplemented");
+
+  if (opts::SectionData)
+    report_fatal_error("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/trunk/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 supported 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);