[Object][XCOFF] Add intial support for parsing/dumping section header table.

[sfertile]

Summary

Adds an representation of the section header table to XCOFFObjectFile, and implements enough to dump the section headers with llvm-obdump.

[hubert.reinterpretcast]

llvm/include/llvm/Object/XCOFFObjectFile.h

126

In keeping with the ordering of overriden functions in this file, this declaration should occur between getFeatures and isRelocatableObject as that is the ordering present in the definition of class ObjectFile.

llvm/lib/Object/XCOFFObjectFile.cpp

40

There is an extra blank line here in comparison to the number of blank lines used between the next few functions below.

42

This should be static or otherwise made to have internal linkage to avoid ODR violations.

127

Do we want to use the version that avoids embedded NUL characters in this patch?

170

It seems (Flags & (XCOFF::STYP_DATA | XCOFF::STYP_TDATA)) is a more common pattern in the codebase.

175

Same comment as above.

299

getObject (called below) takes a Size parameter. It can be used to check for the right number of sections without this call to checkSize.

[sfertile]

1. Addressed @hubert.reinterpretcast comments
2. Added the compiler and source used to generate the object file used in the test.
3. Added test coverage of long section names (ie names of length 8 that are not null terminated)
4. removed the checkSize function as there were no longer any users.

[DiggerLin]

llvm/include/llvm/Object/XCOFFObjectFile.h

24

ObjectFile.h already include SymbolicFile.h , I think there do need SymbolicFile.h here. and also
#include "llvm/Object/Binary.h"
#include "llvm/Object/Error.h"
#include "llvm/BinaryFormat/Magic.h"
#include "llvm/ADT/iterator_range.h"

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

24

Good point, most of these are already included from ObjectFile.h. I'll clean up our header includes but I'll land that in a separate NFC patch.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

24

Didn't intend to mark this done yet.

llvm/lib/Object/XCOFFObjectFile.cpp

299

I've also removed 'checkSize' as it no longer has any uses.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

24

Posted: https://reviews.llvm.org/D60885. I plan to commit that Monday or Tuesday and then I'll rebase this patch to pick up the changes.

[hubert.reinterpretcast]

LGTM with minor changes (no need to post a new revision).

llvm/include/llvm/Object/XCOFFObjectFile.h

24

I'd be happy with seeing this committed and having D60885 adjusted instead.

llvm/test/tools/llvm-objdump/xcoff-section-headers.test

23

Some indication of whether the source is C or C++ (e.g., the base name of the source file) would be helpful.

29

Add a space after the # on this line (and the next few lines) to match the above lines.

[MaskRay]

llvm/test/tools/llvm-objdump/xcoff-section-headers.test

1

Does it need a REQUIRES: line?

[hubert.reinterpretcast]

llvm/test/tools/llvm-objdump/xcoff-section-headers.test

1

No, this is dumping section headers only (not performing disassembly).

llvm/include/llvm/BinaryFormat/XCOFF.h

+//===-- llvm/BinaryFormat/XCOFF.h - The XCOFF file format -------*- C++/-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines manifest constants for the XCOFF object file format.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BINARYFORMAT_XCOFF_H
+#define LLVM_BINARYFORMAT_XCOFF_H
+
+namespace llvm {
+namespace XCOFF {
+
+// Constants used in the XCOFF definition.
+enum { SectionNameSize = 8 };
+
+// Flags for defining the section type. Used for the s_flags field of
+// the section header structure. Defined in the system header `scnhdr.h`.
+enum SectionTypeFlags {
+  STYP_PAD = 0x0008,
+  STYP_DWARF = 0x0010,
+  STYP_TEXT = 0x0020,
+  STYP_DATA = 0x0040,
+  STYP_BSS = 0x0080,
+  STYP_EXCEPT = 0x0100,
+  STYP_INFO = 0x0200,
+  STYP_TDATA = 0x0400,
+  STYP_TBSS = 0x0800,
+  STYP_LOADER = 0x1000,
+  STYP_DEBUG = 0x2000,
+  STYP_TYPCHK = 0x4000,
+  STYP_OVRFLO = 0x8000
+};
+
+} // end namespace XCOFF
+} // end namespace llvm
+
+#endif

llvm/include/llvm/Object/XCOFFObjectFile.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_XCOFFOBJECTFILE_H
 #define LLVM_OBJECT_XCOFFOBJECTFILE_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Magic.h"
+#include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <system_error>
struct XCOFFFileHeader {
   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 {
+  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;
+};
+
 class XCOFFObjectFile : public ObjectFile {
 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;
void getRelocationTypeName(DataRefImpl Rel,
                              SmallVectorImpl<char> &Result) const override;
 
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
   Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override;
+  Expected<uint64_t> getStartAddress() const override;
   bool isRelocatableObject() const override;
 
-public:
   XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC);
 
   const XCOFFFileHeader *getFileHeader() const { return FileHdrPtr; }
-
 }; // XCOFFObjectFile
 
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_XCOFFOBJECTFILE_H

llvm/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 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();
 }
 
+template <typename T> static const T *viewAs(uintptr_t in) {
+  return reinterpret_cast<const T *>(in);
+}
+
+const XCOFFSectionHeader *XCOFFObjectFile::toSection(DataRefImpl Ref) const {
+  auto Sec = viewAs<XCOFFSectionHeader>(Ref.p);
+#ifndef NDEBUG
+  if (Sec < SectionHdrTablePtr ||
+      Sec >= (SectionHdrTablePtr + 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.");
+#endif
+  return Sec;
+}
+
+// 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);
+}
+
+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!");

 
 Expected<section_iterator>
 XCOFFObjectFile::getSymbolSection(DataRefImpl Symb) const {
   llvm_unreachable("Not yet implemented!");
   return section_iterator(SectionRef());
 }
 
 void XCOFFObjectFile::moveSectionNext(DataRefImpl &Sec) const {
-  llvm_unreachable("Not yet implemented!");
-  return;
+  const char *Ptr = reinterpret_cast<const char *>(Sec.p);
+  Sec.p = reinterpret_cast<uintptr_t>(Ptr + getSectionHeaderSize());
 }
 
 std::error_code XCOFFObjectFile::getSectionName(DataRefImpl Sec,
                                                 StringRef &Res) const {
-  llvm_unreachable("Not yet implemented!");
+  const char *Name = toSection(Sec)->Name;
+  auto NulCharPtr =
+      static_cast<const char *>(memchr(Name, '\0', XCOFF::SectionNameSize));
+  Res = NulCharPtr ? StringRef(Name, NulCharPtr - Name)
+                   : StringRef(Name, XCOFF::SectionNameSize);
   return std::error_code();
 }
 
 uint64_t XCOFFObjectFile::getSectionAddress(DataRefImpl Sec) const {
-  uint64_t Result = 0;
-  llvm_unreachable("Not yet implemented!");
-  return Result;
+  return toSection(Sec)->VirtualAddress;
 }
 
 uint64_t XCOFFObjectFile::getSectionIndex(DataRefImpl Sec) const {
-  uint64_t Result = 0;
-  llvm_unreachable("Not yet implemented!");
-  return Result;
+  // 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;
 }
 
 uint64_t XCOFFObjectFile::getSectionSize(DataRefImpl Sec) const {
-  uint64_t Result = 0;
-  llvm_unreachable("Not yet implemented!");
-  return Result;
+  return toSection(Sec)->SectionSize;
 }
 
 std::error_code XCOFFObjectFile::getSectionContents(DataRefImpl Sec,
                                                     StringRef &Res) const {
   llvm_unreachable("Not yet implemented!");
   return std::error_code();
 }
 
 uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
   uint64_t Result = 0;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 
 bool XCOFFObjectFile::isSectionCompressed(DataRefImpl Sec) const {
   bool Result = false;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 
 bool XCOFFObjectFile::isSectionText(DataRefImpl Sec) const {
-  bool Result = false;
-  llvm_unreachable("Not yet implemented!");
-  return Result;
+  return toSection(Sec)->Flags & XCOFF::STYP_TEXT;
 }
 
 bool XCOFFObjectFile::isSectionData(DataRefImpl Sec) const {
-  bool Result = false;
-  llvm_unreachable("Not yet implemented!");
-  return Result;
+  unsigned Flags = toSection(Sec)->Flags;
+  return Flags & (XCOFF::STYP_DATA | XCOFF::STYP_TDATA);
 }
 
 bool XCOFFObjectFile::isSectionBSS(DataRefImpl Sec) const {
-  bool Result = false;
-  llvm_unreachable("Not yet implemented!");
-  return Result;
+  unsigned Flags = toSection(Sec)->Flags;
+  return Flags & (XCOFF::STYP_BSS | XCOFF::STYP_TBSS);
 }
 
 bool XCOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const {
   bool Result = false;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 

 }
 
 basic_symbol_iterator XCOFFObjectFile::symbol_end() const {
   llvm_unreachable("Not yet implemented!");
   return basic_symbol_iterator(SymbolRef());
 }
 
 section_iterator XCOFFObjectFile::section_begin() const {
-  llvm_unreachable("Not yet implemented!");
-  return section_iterator(SectionRef());
+  DataRefImpl DRI;
+  DRI.p = reinterpret_cast<uintptr_t>(SectionHdrTablePtr);
+  return section_iterator(SectionRef(DRI, this));
 }
 
 section_iterator XCOFFObjectFile::section_end() const {
-  llvm_unreachable("Not yet implemented!");
-  return section_iterator(SectionRef());
+  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;
 }
 
 StringRef XCOFFObjectFile::getFileFormatName() const {
-  llvm_unreachable("Not yet implemented!");
-  return "";
+  assert(getFileHeaderSize() == XCOFF32FileHeaderSize);
+  return "aixcoff-rs6000";
 }
 
 Triple::ArchType XCOFFObjectFile::getArch() const {
-  llvm_unreachable("Not yet implemented!");
-  return Triple::UnknownArch;
+  assert(getFileHeaderSize() == XCOFF32FileHeaderSize);
+  return 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;
+}
+
 XCOFFObjectFile::XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
     : ObjectFile(Binary::ID_XCOFF32, Object) {
 
   // Current location within the file.
   uint64_t CurPtr = 0;
 
   if ((EC = getObject(FileHdrPtr, Data, base() + CurPtr)))
     return;
+
+  CurPtr += getFileHeaderSize();
+  // TODO FIXME we don't have support for an optional header yet, so just skip
+  // past it.
+  CurPtr += FileHdrPtr->AuxHeaderSize;
+
+  if (getNumberOfSections() != 0) {
+    if ((EC = getObject(SectionHdrTablePtr, Data, base() + CurPtr,
+                        getNumberOfSections() * getSectionHeaderSize())))
+      return;
+  }
 }
 
 Expected<std::unique_ptr<ObjectFile>>
 ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object) {
   StringRef Data = Object.getBuffer();
   file_magic Type = identify_magic(Data);
   std::error_code EC;
   std::unique_ptr<ObjectFile> Ret;

llvm/test/tools/llvm-objdump/xcoff-section-headers.test

+# RUN: llvm-objdump --section-headers %p/Inputs/xcoff-section-headers.o | \
+# RUN: FileCheck %s
+
+# RUN: llvm-objdump --section-headers %p/Inputs/xcoff-long-sec-names.o | \
+# RUN: FileCheck --check-prefix=LONG %s
+
+# RUN: not llvm-objdump --section-headers 2>&1 \
+# RUN: %p/Inputs/xcoff-section-headers-truncate.o | FileCheck \
+# RUN: --check-prefix=ERROR %s
+
+# ERROR: The end of the file was unexpectedly encountered
+
+# CHECK: xcoff-section-headers.o:      file format aixcoff-rs6000
+# CHECK: Sections:
+# CHECK: Idx Name          Size     VMA          Type
+# CHECK:   1 .text         00000080 0000000000000000 TEXT
+# CHECK:   2 .data         00000024 0000000000000080 DATA
+# CHECK:   3 .bss          00000004 00000000000000a4 BSS
+# CHECK:   4 .tdata        00000008 0000000000000000 DATA
+# CHECK:   5 .tbss         00000004 0000000000000008 BSS
+
+# xcoff-section-headers.o Compiled with IBM XL C/C++ for AIX, V16.1.0
+# source:
+# int a;
+# int b = 12345;
+# __thread int c;
+# __thread double d = 3.14159;
+#
+#int func(void)  {
+#  return a;
+#}
+
+# LONG: xcoff-long-sec-names.o:      file format aixcoff-rs6000
+# LONG: Sections:
+# LONG: Idx Name          Size     VMA          Type
+# LONG: 1 .dwarnge      00000004 0000000000000000
+# LONG: 2 .dwpbnms      00000004 0000000000000000
+# LONG: 3 .dwpbtyp      00000004 0000000000000000
+
+# xcoff-long-sec-names.o was generated by assembling the following .s file:
+#  .dwsect 0x30000 # .dwpbnms section
+#  .dwsect 0x40000 # .dwpbtyp section
+#  .dwsect 0x50000 # .dwarnge section