[Object][XCOFF] Add an XCOFF dumper for llvm-readobj

[sfertile]

Summary

Patch adds support for dumping of file headers with llvm-readobj. XCOFF object files are added to test dumping a well formed file, and dumping both negative timestamps and negative symbol counts, both of which are allowed in the XCOFF definition.

Note this patch is dependent on https://reviews.llvm.org/D60784

[daltenty]

The format of the binaries included in the patch don't seem correct, they create empty files. As a result the corresponding test are failing.

[sfertile]

In D60878#1475619, @daltenty wrote:

The format of the binaries included in the patch don't seem correct, they create empty files. As a result the corresponding test are failing.

The diff just shows that a binary file was added. If you want the actual binaries let me know and I can put them somewhere you can grab them.

[daltenty]

Retested with binaries. Looks good to me.

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

314 ↗

(On Diff #195773)

The field being returned is unsigned. The return type does not match.

329 ↗

(On Diff #195773)

The field being returned is 16-bit. The return type does not match.

[sfertile]

Fixed return types to match the type of field being accessed.

[hubert.reinterpretcast]

LGTM.

[MaskRay]

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

1 ↗

(On Diff #197382)

// REQUIRES: powerpc-registered-target ?

arc patch D60878 gives me empty xcoff-basic-neg-time.o. I can't verify their architectures.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

44 ↗

(On Diff #197382)

Delete the empty line.

[hubert.reinterpretcast]

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

1 ↗

(On Diff #197382)

I believe you asked this before on D60784. The functionality being tested is available even without enabling what the build system considers the PowerPC target-specific code.

@sfertile, I don't know how you generated the diff and whether or not this would work, but we may want to give the --binary option of git diff a try:

diff --git a/llvm/test/tools/obj2yaml/Inputs/aix_xcoff.o b/llvm/test/tools/obj2yaml/Inputs/aix_xcoff.o
new file mode 100644
index 0000000000000000000000000000000000000000..3712f7f853e506d8c0bcf2922e7f61c8b63cffee
GIT binary patch
literal 588
zcmZ8eyH3ME5S()i;-v&rBBVG_LE$O|REb0t5fKVX3R}b=i${YC7a%3#3lMw=AHqKn
z{sUoV_s)r7q+O49XLs-R%qP5y(Lon5D*(1=i1M_^g)A^69n(HE<f#v%agrxWA$hSK
z+B<DV1AO)U*RS&Xty9h(d+Wt?7ntq?M*|q)F9Y%rc-lKD4tofnsXd*55n?rrCkBSB
z3;!<3?%Nusle5$zvjt7sW~)KJJ!g_z*2*)orm~pKS0<gjHlnNSHYF95KWJQ=JblQc
zOB=C1tN)ODa<U5cu77vO{EcYb=>n&X<SJDi^V-MN+tmU!$q)=`pAB0Stl95>jrNgO
nBs{07y-_^x<7Rc1toD3#Y>Di(n&l!v%aYpN7aG?mkbM)srs_94

literal 0
HcmV?d00001

[sfertile]

Removed extra blank lines and added binaries into the diff.

[sfertile]

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

1 ↗

(On Diff #197382)

@MaskRay wrote:

// REQUIRES: powerpc-registered-target ?

No, the tests don't need a registered powerpc target, the only dependence is on XCOFFObjectFile from lib/Object which gets built on all platforms.

@hubert.reinterpretcast wrote:

we may want to give the --binary option of git diff a try

Thanks, I wasn't aware of this. I'll make sure to include the binaries in diffs from now on.

[hubert.reinterpretcast]

It looks like (at least this instance of) Phabricator does not do much better with the binary patch. arc export does generate GIT binary patch output, but it does not appear to reflect the intended content.

llvm/trunk/include/llvm/Object/XCOFFObjectFile.h

private:
   const XCOFFFileHeader *FileHdrPtr = nullptr;
   const XCOFFSectionHeader *SectionHdrTablePtr = nullptr;
 
   size_t getFileHeaderSize() const;
   size_t getSectionHeaderSize() const;
 
   const XCOFFSectionHeader *toSection(DataRefImpl Ref) const;
 
-  uint16_t getNumberOfSections() 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;
public:
   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);
 
   const XCOFFFileHeader *getFileHeader() const { return FileHdrPtr; }
+
+  uint16_t getMagic() const;
+  uint16_t getNumberOfSections() const;
+  int32_t  getTimeStamp() const;
+  uint32_t  getSymbolTableOffset() const;
+
+  // Note that this value is signed and might return a negative value. Negative
+  // values are reserved for future use.
+  int32_t  getNumberOfSymbolTableEntries() const;
+
+  uint16_t getOptionalHeaderSize() const;
+  uint16_t getFlags() const;
 }; // XCOFFObjectFile
 
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_XCOFFOBJECTFILE_H

llvm/trunk/lib/Object/XCOFFObjectFile.cpp

 size_t XCOFFObjectFile::getFileHeaderSize() const {
   return sizeof(XCOFFFileHeader);
 }
 
 size_t XCOFFObjectFile::getSectionHeaderSize() const {
   return sizeof(XCOFFSectionHeader);
 }
 
-uint16_t XCOFFObjectFile::getNumberOfSections() const {
-  return FileHdrPtr->NumberOfSections;
-}
-
 void XCOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
   llvm_unreachable("Not yet implemented!");
   return;
 }
 
 Expected<StringRef> XCOFFObjectFile::getSymbolName(DataRefImpl Symb) const {
   StringRef Result;
   llvm_unreachable("Not yet implemented!");

 section_iterator XCOFFObjectFile::section_end() const {
   DataRefImpl DRI;
   DRI.p =
       reinterpret_cast<uintptr_t>(SectionHdrTablePtr + getNumberOfSections());
   return section_iterator(SectionRef(DRI, this));
 }
 
 uint8_t XCOFFObjectFile::getBytesInAddress() const {
-  uint8_t Result = 0;
-  llvm_unreachable("Not yet implemented!");
-  return Result;
+  // Only support 32-bit object files for now ...
+  assert(getFileHeaderSize() ==  XCOFF32FileHeaderSize);
+  return 4;
 }
 
 StringRef XCOFFObjectFile::getFileFormatName() const {
   assert(getFileHeaderSize() == XCOFF32FileHeaderSize);
   return "aixcoff-rs6000";
 }
 
 Triple::ArchType XCOFFObjectFile::getArch() const {
XCOFFObjectFile::XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
 
   if (getNumberOfSections() != 0) {
     if ((EC = getObject(SectionHdrTablePtr, Data, base() + CurPtr,
                         getNumberOfSections() * getSectionHeaderSize())))
       return;
   }
 }
 
+uint16_t XCOFFObjectFile::getMagic() const {
+  return FileHdrPtr->Magic;
+}
+
+uint16_t XCOFFObjectFile::getNumberOfSections() const {
+  return FileHdrPtr->NumberOfSections;
+}
+
+int32_t XCOFFObjectFile::getTimeStamp() const {
+  return FileHdrPtr->TimeStamp;
+}
+
+uint32_t XCOFFObjectFile::getSymbolTableOffset() const {
+  return FileHdrPtr->SymbolTableOffset;
+}
+
+int32_t XCOFFObjectFile::getNumberOfSymbolTableEntries() 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 FileHdrPtr->NumberOfSymTableEntries;
+}
+
+uint16_t XCOFFObjectFile::getOptionalHeaderSize() const {
+  return FileHdrPtr->AuxHeaderSize;
+}
+
+uint16_t XCOFFObjectFile::getFlags() const {
+  return FileHdrPtr->Flags;
+}
+
 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) {

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-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: }
+
+# 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)
+# NEGTIME-NEXT:    SymbolTableOffset: 0x52E
+# NEGTIME-NEXT:    SymbolTableEntries: 120
+# NEGTIME-NEXT:    OptionalHeaderSize: 0x1C
+# NEGTIME-NEXT:    Flags: 0x0
+# NEGTIME-NEXT:  }
+
+# NEGSYMCOUNT:     File: {{.*}}xcoff-basic-neg-sym-count.o
+# NEGSYMCOUNT-NEXT:  Format: aixcoff-rs6000
+# NEGSYMCOUNT-NEXT:  Arch: powerpc
+# NEGSYMCOUNT-NEXT:  AddressSize: 32bit
+# NEGSYMCOUNT-NEXT:  FileHeader {
+# NEGSYMCOUNT-NEXT:    Magic: 0x1DF
+# NEGSYMCOUNT-NEXT:    NumberOfSections: 5
+# NEGSYMCOUNT-NEXT:    TimeStamp: 2019-03-12T14:04:43Z (0x5C87BC7B)
+# NEGSYMCOUNT-NEXT:    SymbolTableOffset: 0x0
+# NEGSYMCOUNT-NEXT:    SymbolTableEntries: Reserved Value (0x80000000)
+# NEGSYMCOUNT-NEXT:    OptionalHeaderSize: 0x1C
+# NEGSYMCOUNT-NEXT:    Flags: 0xD
+# NEGSYMCOUNT-NEXT:  }
+
+# xcoff-basic.o was compiled with `xlc -qtls -O3 -g -c xcoff-basic.c`
+# from the following source:
+# int a = 55;
+# int b;
+# __thread int j = 55;
+# __thread double d;
+# int A() { return a; }
+# int B() { return b; }
+# int J() { return j; }
+# double D() { return d; }
+#
+# xcoff-basic-neg-time.o was manually edited to include a negative time stamp.
+# xcoff-basic-neg-sym-count.o was stripped using the 'strip' utility, and
+# manually edited to have a negative symbol table entry count.
+

llvm/trunk/tools/llvm-readobj/CMakeLists.txt

add_llvm_tool(llvm-readobj
   ELFDumper.cpp
   Error.cpp
   llvm-readobj.cpp
   MachODumper.cpp
   ObjDumper.cpp
   WasmDumper.cpp
   Win64EHDumper.cpp
   WindowsResourceDumper.cpp
+  XCOFFDumper.cpp
   )
 
 add_llvm_tool_symlink(llvm-readelf llvm-readobj)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(readelf llvm-readobj)
 endif()

llvm/trunk/tools/llvm-readobj/ObjDumper.h

 std::error_code createMachODumper(const object::ObjectFile *Obj,
                                   ScopedPrinter &Writer,
                                   std::unique_ptr<ObjDumper> &Result);
 
 std::error_code createWasmDumper(const object::ObjectFile *Obj,
                                  ScopedPrinter &Writer,
                                  std::unique_ptr<ObjDumper> &Result);
 
+std::error_code createXCOFFDumper(const object::ObjectFile *Obj,
+                                  ScopedPrinter &Writer,
+                                  std::unique_ptr<ObjDumper> &Result);
+
 void dumpCOFFImportFile(const object::COFFImportFile *File,
                         ScopedPrinter &Writer);
 
 void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
                              ArrayRef<ArrayRef<uint8_t>> IpiRecords,
                              ArrayRef<ArrayRef<uint8_t>> TpiRecords);
 
 } // namespace llvm
 
 #endif

llvm/trunk/tools/llvm-readobj/XCOFFDumper.cpp

+//===-- XCOFFDumper.cpp - XCOFF dumping utility -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements an XCOFF specific dumper for llvm-readobj.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+#include "ObjDumper.h"
+#include "llvm-readobj.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace object;
+
+namespace {
+
+class XCOFFDumper : public ObjDumper {
+public:
+  XCOFFDumper(const XCOFFObjectFile &Obj, ScopedPrinter &Writer)
+      : ObjDumper(Writer), Obj(Obj) {}
+
+  void printFileHeaders() override;
+  void printSectionHeaders() override;
+  void printRelocations() override;
+  void printSymbols() override;
+  void printDynamicSymbols() override;
+  void printUnwindInfo() override;
+  void printStackMap() const override;
+  void printNeededLibraries() override;
+
+private:
+  const XCOFFObjectFile &Obj;
+};
+} // anonymous namespace
+
+void XCOFFDumper::printFileHeaders() {
+  DictScope DS(W, "FileHeader");
+  W.printHex("Magic", Obj.getMagic());
+  W.printNumber("NumberOfSections", Obj.getNumberOfSections());
+
+  // Negative timestamp values are reserved for future use.
+  int32_t TimeStamp = Obj.getTimeStamp();
+  if (TimeStamp > 0) {
+    // This handling of the time stamp assumes that the host system's time_t is
+    // compatible with AIX time_t. If a platform is not compatible, the lit
+    // tests will let us know.
+    time_t TimeDate = TimeStamp;
+
+    char FormattedTime[21] = {};
+    size_t BytesWritten =
+        strftime(FormattedTime, 21, "%Y-%m-%dT%H:%M:%SZ", gmtime(&TimeDate));
+    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.getNumberOfSymbolTableEntries();
+  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");
+}
+
+void XCOFFDumper::printRelocations() {
+  llvm_unreachable("Unimplemented functionality for XCOFFDumper");
+}
+
+void XCOFFDumper::printSymbols() {
+  llvm_unreachable("Unimplemented functionality for XCOFFDumper");
+}
+
+void XCOFFDumper::printDynamicSymbols() {
+  llvm_unreachable("Unimplemented functionality for XCOFFDumper");
+}
+
+void XCOFFDumper::printUnwindInfo() {
+  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");
+}
+
+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/llvm-readobj/llvm-readobj.cpp

static std::error_code createDumper(const ObjectFile *Obj,
   if (Obj->isCOFF())
     return createCOFFDumper(Obj, Writer, Result);
   if (Obj->isELF())
     return createELFDumper(Obj, Writer, Result);
   if (Obj->isMachO())
     return createMachODumper(Obj, Writer, Result);
   if (Obj->isWasm())
     return createWasmDumper(Obj, Writer, Result);
+  if (Obj->isXCOFF())
+    return createXCOFFDumper(Obj, Writer, Result);
 
   return readobj_error::unsupported_obj_file_format;
 }
 
 /// Dumps the specified object file.
 static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer) {
   std::unique_ptr<ObjDumper> Dumper;
   if (std::error_code EC = createDumper(Obj, Writer, Dumper))