[SystemZ/z/OS] Add GOFF reader

[yusra.syeda]

Summary

This patch consists of changes required to implement the GOFF reader for z/OS. It contains a test which uses llvm-readobj to check the symbols and relocations of the provided object file.
This patch uses https://reviews.llvm.org/D88741

[MaskRay]

You may consider moving llvm-objdump to a separate patch. Some parts should be tested by a unittest in unittest/Object/

llvm/include/llvm/BinaryFormat/GOFF.h

31

const -> constexpr

llvm/lib/Object/Binary.cpp

70

Don't break the continuation of coff_* file types.

llvm/lib/Object/GOFFObjectFile.cpp

261

http://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

This applies to many other places

[kpn]

Are you planning on supporting the case where an ED has a nonzero offset? For a general purpose dumper it matters: HLASM.

[yusra.syeda]

Fix formatting issues

[jhenderson]

In D88749#2312658, @yusra.syeda wrote:

Fix formatting issues

It looks to me like you uploaded the wrong diff. You need to upload a diff of your entire final commit that this will be committed as, when making edits to the code. If you intend to upload a series of individual commits, and want them all reviewed together, you should create separate patches for each of them and link them together using the "edit related objects" option to create a patch series.

This patch adds support for a large number of different dumping options all at once. Please break it down into separate smaller pieces. For example, your first patch could just create the GOFFDumper, and do nothing with it, the next adds section header support, the next symbol table support and so on. It is not going to be straightforward to review such a large piece of work all at once.

[yusra.syeda]

This update uploads the correct diff with all changes

[yusra.syeda]

It looks to me like you uploaded the wrong diff. You need to upload a diff of your entire final commit that this will be committed as, when making edits to the code. If you intend to upload a series of individual commits, and want them all reviewed together, you should create separate patches for each of them and link them together using the "edit related objects" option to create a patch series.

This patch adds support for a large number of different dumping options all at once. Please break it down into separate smaller pieces. For example, your first patch could just create the GOFFDumper, and do nothing with it, the next adds section header support, the next symbol table support and so on. It is not going to be straightforward to review such a large piece of work all at once.

Thanks for the review. I will break this patch down.

[yusra.syeda]

This patch has been broken down into the following 3 patches:
https://reviews.llvm.org/D89071
https://reviews.llvm.org/D89073
https://reviews.llvm.org/D89074

llvm/include/llvm/BinaryFormat/GOFF.h

+//===-- llvm/BinaryFormat/GOFF.h - GOFF definitions ---------------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This header contains common, non-processor-specific data structures and
+// constants for the GOFF file format.
+//
+// The details of the GOFF32 bits in this file are largely based on the Tool
+// Interface Standard (TIS) Executable and Linking Format (GOFF) Specification
+// Version 1.2, May 1995. The GOFF64 specifics are based on GOFF-64 Object File
+// Format
+// Version 1.5, Draft 2, May 1998 as well as OpenBSD header files.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BINARYFORMAT_GOFF_H
+#define LLVM_BINARYFORMAT_GOFF_H
+
+#include "llvm/Support/DataTypes.h"
+
+namespace llvm {
+
+namespace GOFF {
+
+constexpr uint8_t RecordLength = 80;
+
+/// \brief Maximum data length before starting a new card for RLD and TXT data.
+///
+/// The maximum number of bytes that can be included in an RLD or TXT record and
+/// their continuations is a SIGNED 16 bit int despite what the spec says. The
+/// number of bytes we allow ourselves to attach to a card is thus arbitrarily
+/// limited to 16K bytes.
+const uint16_t MaxDataLength = 16 * 1024;
+
+// Prefix byte on every record.  This indicates GOFF format.
+enum { PTVPrefix = 0x03 };
+
+enum RecordType {
+  RT_ESD = 0,
+  RT_TXT = 1,
+  RT_RLD = 2,
+  RT_LEN = 3,
+  RT_END = 4,
+  RT_HDR = 15,
+};
+
+enum ESDSymbolType {
+  ESD_ST_SectionDefinition = 0,
+  ESD_ST_ElementDefinition = 1,
+  ESD_ST_LabelDefinition = 2,
+  ESD_ST_PartReference = 3,
+  ESD_ST_ExternalReference = 4,
+};
+
+enum ESDNameSpaceId {
+  ESD_NS_ProgramManagementBinder = 0,
+  ESD_NS_NormalName = 1,
+  ESD_NS_PseudoRegister = 2,
+  ESD_NS_Parts = 3
+};
+
+enum ESDReserveQwords {
+  ESD_RQ_0 = 0,
+  ESD_RQ_1 = 1,
+  ESD_RQ_2 = 2,
+  ESD_RQ_3 = 3
+};
+
+enum ESDERSymbolType {
+  ESD_ES_None = 0,
+  ESD_ES_Section = 1,
+  ESD_ES_Label = 2,
+  ESD_ES_Class = 3,
+  ESD_ES_Part = 4
+};
+
+enum ESDAmode {
+  ESD_AMODE_None = 0,
+  ESD_AMODE_24 = 1,
+  ESD_AMODE_31 = 2,
+  ESD_AMODE_ANY = 3,
+  ESD_AMODE_64 = 4,
+  ESD_AMODE_MIN = 16,
+};
+
+enum ESDRmode {
+  ESD_RMODE_None = 0,
+  ESD_RMODE_24 = 1,
+  ESD_RMODE_31 = 3,
+  ESD_RMODE_64 = 4,
+};
+
+enum ESDTextStyle {
+  ESD_TS_ByteOriented = 0,
+  ESD_TS_Structured = 1,
+  ESD_TS_Unstructured = 2,
+};
+
+enum ESDBindingAlgorithm {
+  ESD_BA_Concatenate = 0,
+  ESD_BA_Merge = 1,
+};
+
+enum ESDTaskingBehavior {
+  ESD_TA_Unspecified = 0,
+  ESD_TA_NonReus = 1,
+  ESD_TA_Reus = 2,
+  ESD_TA_Rent = 3,
+};
+
+enum ESDExecutable {
+  ESD_EXE_Unspecified = 0,
+  ESD_EXE_DATA = 1,
+  ESD_EXE_CODE = 2,
+};
+
+enum ESDDuplicateSymbolSeverity {
+  ESD_DSS_NoWarning = 0,
+  ESD_DSS_Warning = 1,
+  ESD_DSS_Error = 2,
+  ESD_DSS_Reserved = 3,
+};
+
+enum ESDBindingStrength {
+  ESD_BST_Strong = 0,
+  ESD_BST_Weak = 1,
+};
+
+enum ESDLoadingBehavior {
+  ESD_LB_Initial = 0,
+  ESD_LB_Deferred = 1,
+  ESD_LB_NoLoad = 2,
+  ESD_LB_Reserved = 3,
+};
+
+enum ESDBindingScope {
+  ESD_BSC_Unspecified = 0,
+  ESD_BSC_Section = 1,
+  ESD_BSC_Module = 2,
+  ESD_BSC_Library = 3,
+  ESD_BSC_ImportExport = 4,
+};
+
+enum ESDLinkageType { ESD_LT_OS = 0, ESD_LT_XPLink = 1 };
+
+enum ESDAlignment {
+  ESD_ALIGN_Byte = 0,
+  ESD_ALIGN_Halfword = 1,
+  ESD_ALIGN_Fullword = 2,
+  ESD_ALIGN_Doubleword = 3,
+  ESD_ALIGN_Quadword = 4,
+  ESD_ALIGN_32byte = 5,
+  ESD_ALIGN_64byte = 6,
+  ESD_ALIGN_128byte = 7,
+  ESD_ALIGN_256byte = 8,
+  ESD_ALIGN_512byte = 9,
+  ESD_ALIGN_1024byte = 10,
+  ESD_ALIGN_2Kpage = 11,
+  ESD_ALIGN_4Kpage = 12,
+};
+
+enum TXTRecordStyle {
+  TXT_RS_Byte = 0,
+  TXT_RS_Structured = 1,
+  TXT_RS_Unstructured = 2,
+};
+
+// RLDRelocationType is internal use only and these values not put
+// in GOFF format
+enum RLDRelocationType {
+  Reloc_Type_Adcon = 0,
+  Reloc_Type_Vcon = 1,
+  Reloc_Type_Qcon = 2,
+  Reloc_Type_Len = 3,
+  Reloc_Type_Ada = 4,
+  Reloc_Type_Rel_Imm = 5,
+  Reloc_Type_Rel = 6,
+  Reloc_Type_Long_Disp = 7,
+  Reloc_Type_Cond_Vcon = 8
+};
+
+enum RLDReferenceType {
+  RLD_RT_RAddress = 0,
+  RLD_RT_ROffset = 1,
+  RLD_RT_RLength = 2,
+  RLD_RT_RRelativeImmediate = 6,
+  RLD_RT_RTypeConstant = 7,
+  RLD_RT_RLongDisplacement = 9,
+};
+
+enum RLDReferentType {
+  RLD_RO_Label = 0,
+  RLD_RO_Element = 1,
+  RLD_RO_Class = 2,
+  RLD_RO_Part = 3,
+};
+
+enum RLDAction {
+  RLD_ACT_Multiply = 4,
+  RLD_ACT_Div4Quotient = 6,
+  RLD_ACT_Div4Remainder = 7,
+  RLD_ACT_And = 8,
+  RLD_ACT_Or = 9,
+  RLD_ACT_Xor = 10,
+  RLD_ACT_Move = 16
+};
+
+enum RLDFetchStore { RLD_FS_Fetch = 0, RLD_FS_Store = 1 };
+
+enum ENDEntryPointRequest {
+  END_EPR_None = 0,
+  END_EPR_EsdidOffset = 1,
+  END_EPR_ExternalName = 2,
+  END_EPR_Reserved = 3,
+};
+
+// \brief Represent the different types of objects that can be referenced from
+// the associated data area (ADA) of a compilation unit.
+enum ADASlotKind {
+#define ADASLOT(SLOT, MO, V) SLOT = V,
+#include "llvm/BinaryFormat/GOFFAda.def"
+};
+
+// \brief Subsections of the primary C_CODE section in the object file.
+enum SubsectionKind {
+  SK_ReadOnly = 1,
+  SK_PPA1 = 2,
+  SK_JumpTable = 3,
+  SK_PPA2 = 4,
+};
+
+} // end namespace GOFF
+
+} // end namespace llvm
+
+#endif // LLVM_BINARYFORMAT_GOFF_H

llvm/include/llvm/BinaryFormat/GOFFAda.def

+//===-- GOFFAda.def ---------------------------------------------*- 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 centralizes the ADA definitions used by GOFF and XPLINK.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ADASLOT
+#define ADASLOT(SLOT, MO, V)
+#endif
+
+/// ADASLOT(SLOT, MO, V)
+///
+/// \param SLOT - ADA slot kind in file
+/// \param MO   - Corresponding machine operand kind
+/// \param V    - Enumeration value
+
+// The address of a non-function (data) symbol.
+ADASLOT(ADA_DataSymbolAddr, MO_ADA_DATA_SYMBOL_ADDR, 1)
+// The address of a function descriptor.
+ADASLOT(ADA_IndirectFuncDesc, MO_ADA_INDIRECT_FUNC_DESC, 2)
+// A function descriptor. Contains the address of the ADA for a function and
+// the address of the function.
+ADASLOT(ADA_DirectFuncDesc, MO_ADA_DIRECT_FUNC_DESC, 3)
+// The address of the ADA for a function. Part of a function descriptor.
+ADASLOT(ADA_DirectFuncDescADA, MO_ADA_DIRECT_FUNC_DESC_ADA, 4)
+// The address of a function. Part of a function descriptor.
+ADASLOT(ADA_DirectFuncDescAddr, MO_ADA_DIRECT_FUNC_DESC_EPA, 5)
+// The address of a data symbol's handle, that is, the address of the symbol
+// referenced. This is how external data is referenced.
+ADASLOT(ADA_DataSymbolHandle, MO_ADA_DATA_SYMBOL_ADDR_VIA_HANDLE, 6)
+// Access ADA entry containing pointer to internal data symbol.
+ADASLOT(ADA_InternalDataSymbolAddr, MO_ADA_INTERNAL_DATA_SYMBOL_ADDR, 7)
+
+#undef ADASLOT

llvm/include/llvm/BinaryFormat/Magic.h

 //===- llvm/BinaryFormat/Magic.h - File magic identification ----*- 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
 //
 //===----------------------------------------------------------------------===//
 
enum Impl {
     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
+    goff_object,         ///< GOFF object file
     tapi_file,           ///< Text-based Dynamic Library Stub file
   };
 
   bool is_object() const { return V != unknown; }
 
   file_magic() = default;
   file_magic(Impl V) : V(V) {}
   operator Impl() const { return V; }

llvm/include/llvm/Object/Binary.h

 //===- Binary.h - A generic binary file -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
enum {
     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
     ID_MachO64L, // MachO 64-bit, little endian
     ID_MachO64B, // MachO 64-bit, big endian
 
+    ID_GOFF,
     ID_Wasm,
 
     ID_EndObjects
   };
 
   static inline unsigned int getELFType(bool isLE, bool is64Bits) {
     if (isLE)
       return is64Bits ? ID_ELF64L : ID_ELF32L;
public:
   bool isCOFFImportFile() const {
     return TypeID == ID_COFFImportFile;
   }
 
   bool isIR() const {
     return TypeID == ID_IR;
   }
 
+  bool isGOFF() const { return TypeID == ID_GOFF; }
+
   bool isMinidump() const { return TypeID == ID_Minidump; }
 
   bool isTapiFile() const { return TypeID == ID_TapiFile; }
 
   bool isLittleEndian() const {
     return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B ||
              TypeID == ID_MachO32B || TypeID == ID_MachO64B);
   }
 
   bool isWinRes() const { return TypeID == ID_WinRes; }
 
   Triple::ObjectFormatType getTripleObjectFormat() const {
     if (isCOFF())
       return Triple::COFF;
     if (isMachO())
       return Triple::MachO;
     if (isELF())
       return Triple::ELF;
+    if (isGOFF())
+      return Triple::GOFF;
     return Triple::UnknownObjectFormat;
   }
 
   static Error checkOffset(MemoryBufferRef M, uintptr_t Addr,
                            const uint64_t Size) {
     if (Addr + Size < Addr || Addr + Size < Size ||
         Addr + Size > uintptr_t(M.getBufferEnd()) ||
         Addr < uintptr_t(M.getBufferStart())) {

llvm/include/llvm/Object/GOFF.h

+//===- GOFF.h - GOFF object file implementation -----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the GOFFObjectFile class.
+// Record classes and derivatives are also declared and implemented.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_GOFF_H
+#define LLVM_OBJECT_GOFF_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/BinaryFormat/GOFF.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+struct GOFFRelocationEntry {
+  const uint32_t REsdId;
+  const uint32_t PEsdId;
+  const uint64_t POffset;
+
+  const GOFF::RLDReferenceType ReferenceType;
+  const GOFF::RLDReferentType ReferentType;
+  const GOFF::RLDAction Action;
+  const bool NoFetchTarget;
+  const uint32_t TargetLength;
+
+  GOFFRelocationEntry(uint32_t REsdId_, uint32_t PEsdId_, uint64_t POffset_,
+                      GOFF::RLDReferenceType ReferenceType_,
+                      GOFF::RLDReferentType ReferentType_,
+                      GOFF::RLDAction Action_, bool NoFetchTarget_,
+                      uint32_t TargetLength_)
+      : REsdId(REsdId_), PEsdId(PEsdId_), POffset(POffset_),
+        ReferenceType(ReferenceType_), ReferentType(ReferentType_),
+        Action(Action_), NoFetchTarget(NoFetchTarget_),
+        TargetLength(TargetLength_) {}
+};
+
+namespace object {
+
+/// \brief Represents a GOFF physical record.
+///
+/// Specifies protected member functions to manipulate the record. These should
+/// be called from deriving classes to change values as that record specifies.
+class Record {
+  SmallVector<char, GOFF::RecordLength> Bytes;
+
+public:
+  Record() : Bytes(GOFF::RecordLength, (char)0x00) {
+    set8(0, GOFF::PTVPrefix);
+  };
+
+  // Set PTV fields common to all records
+  void setRecordType(GOFF::RecordType RecordType) {
+    setBits(1, 0, 4, RecordType);
+  }
+
+  void setContinuation(bool Continuation) {
+    uint8_t Value = Continuation ? 1 : 0;
+    setBits(1, 6, 1, Value);
+  }
+
+  void setContinued(bool Continued) {
+    uint8_t Value = Continued ? 1 : 0;
+    setBits(1, 7, 1, Value);
+  }
+
+  const SmallVectorImpl<char> &getBytes() const { return Bytes; }
+
+protected:
+  /// \brief Set bit field of specified byte.
+  ///
+  /// Used to pack bit fields into one byte. Fields are packed LEFT TO RIGHT.
+  /// Bit index zero is the MOST SIGNIFICANT BIT of the byte.
+  ///
+  /// \param ByteIndex index of byte the field is in
+  /// \param BitIndex index of first bit of field
+  /// \param Length length of bit field
+  /// \param Value new value of bit field
+  void setBits(uint8_t ByteIndex, uint8_t BitIndex, uint8_t Length,
+               uint8_t Value) {
+    assert(ByteIndex < GOFF::RecordLength && "Byte index out of bounds!");
+    assert(BitIndex < 8 && "Bit index out of bounds!");
+    assert(Length + BitIndex <= 8 && "Bit length too long!");
+
+    uint8_t Mask = ((1 << Length) - 1) << (8 - BitIndex - Length);
+    Value = Value << (8 - BitIndex - Length);
+    assert((Value & Mask) == Value && "Bits set outside of range!");
+
+    Bytes[ByteIndex] &= ~Mask; // Clear bits to set
+    Bytes[ByteIndex] |= Value;
+  }
+
+  /// \brief Set byte of record
+  void set8(uint8_t ByteIndex, uint8_t Value) {
+    assert(ByteIndex < GOFF::RecordLength && "Byte index out of bounds!");
+    Bytes[ByteIndex] = static_cast<char>(Value);
+  }
+
+  /// \brief Set two bytes of record, accounting for endianness
+  void set16(uint8_t ByteIndex, uint16_t Value) {
+    assert(ByteIndex + 1 < GOFF::RecordLength && "Byte index out of bounds!");
+
+    for (int I = 0; I < 2; ++I) {
+      uint16_t Temp = (Value >> (8 * I)) & 0xFF;
+      Bytes[ByteIndex + 1 - I] = static_cast<char>(Temp);
+    }
+  }
+
+  /// \brief Set four bytes of record, accounting for endianness
+  void set32(uint8_t ByteIndex, uint32_t Value) {
+    assert(ByteIndex + 3 < GOFF::RecordLength && "Byte index out of bounds!");
+
+    for (int I = 0; I < 4; ++I) {
+      uint32_t Temp = (Value >> (8 * I)) & 0xFF;
+      Bytes[ByteIndex + 3 - I] = static_cast<char>(Temp);
+    }
+  }
+
+  // Get routine
+  static void getBits(const uint8_t *Bytes, uint8_t ByteIndex, uint8_t BitIndex,
+                      uint8_t Length, uint8_t &Value) {
+    assert(ByteIndex < GOFF::RecordLength && "Byte index out of bounds!");
+    assert(BitIndex < 8 && "Bit index out of bounds!");
+    assert(Length + BitIndex <= 8 && "Bit length too long!");
+
+    uint8_t Mask = ((1 << Length) - 1) << (8 - BitIndex - Length);
+    Value = Bytes[ByteIndex] & Mask;
+    Value = Value >> (8 - BitIndex - Length);
+  }
+
+  static void get8(const uint8_t *Bytes, uint8_t ByteIndex, uint8_t &Value) {
+    assert(ByteIndex < GOFF::RecordLength && "Byte index out of bounds!");
+    Value = Bytes[ByteIndex];
+  }
+
+  static void get16(const uint8_t *Bytes, uint8_t ByteIndex, uint16_t &Value) {
+    assert(ByteIndex + 1 < GOFF::RecordLength && "Byte index out of bounds!");
+
+    Value = *reinterpret_cast<const uint16_t *>(&Bytes[ByteIndex]);
+  }
+
+  static void get32(const uint8_t *Bytes, uint8_t ByteIndex, uint32_t &Value) {
+    assert(ByteIndex + 3 < GOFF::RecordLength && "Byte index out of bounds!");
+
+    Value = *reinterpret_cast<const uint32_t *>(&Bytes[ByteIndex]);
+  }
+};
+
+class HDRRecord : public Record {
+public:
+  HDRRecord() : Record() {
+    setRecordType(GOFF::RT_HDR);
+    setArchitectureLevel(1);
+  }
+
+  void setArchitectureLevel(uint32_t Level) { set32(48, Level); }
+};
+
+class TXTRecord : public Record {
+public:
+  /// \brief Maximum length of data; any more must go in continuation.
+  static const uint8_t TXTMaxDataLength = 56;
+
+public:
+  TXTRecord() : Record() { setRecordType(GOFF::RT_TXT); }
+
+  void setRecordStyle(GOFF::TXTRecordStyle Style) { setBits(3, 4, 4, Style); }
+
+  void setElementEsdId(uint32_t EsdId) { set32(4, EsdId); }
+
+  void setOffset(uint32_t Offset) { set32(12, Offset); }
+
+  void setDataLength(uint16_t Length) { set16(22, Length); }
+
+  void setData(const SmallVectorImpl<char>::const_iterator &Data,
+               uint8_t Length) {
+    assert(Length <= TXTMaxDataLength && "Data too long for TXT Record");
+
+    for (int I = 0; I < Length; ++I)
+      set8(24 + I, Data[I]);
+  }
+
+  // Get routines
+  static void getElementEsdId(const uint8_t *Record, uint32_t &EsdId) {
+    get32(Record, 4, EsdId);
+  }
+
+  static void getOffset(const uint8_t *Record, uint32_t &Offset) {
+    get32(Record, 12, Offset);
+  }
+
+  static void getDataLength(const uint8_t *Record, uint16_t &Length) {
+    get16(Record, 22, Length);
+  }
+};
+
+class ESDRecord : public Record {
+public:
+  /// \brief Number of bytes for name; any more must go in continuation.
+  /// This is the number of bytes that can fit into the data field of an ESD
+  /// record.
+  static const uint8_t ESDMaxNameLength = 8;
+
+  /// \brief Maximum name length for ESD records and continuations.
+  /// This is the number of bytes that can fit into the data field of an ESD
+  /// record AND following continuations. This is limited fundamentally by the
+  /// 16 bit SIGNED length field.
+  static const uint16_t MaxNameLength = 32 * 1024;
+
+public:
+  ESDRecord() : Record() { setRecordType(GOFF::RT_ESD); }
+
+  void setSymbolType(GOFF::ESDSymbolType SymbolType) { set8(3, SymbolType); }
+
+  void setEsdId(uint32_t EsdId) { set32(4, EsdId); }
+
+  void setParentEsdId(uint32_t EsdId) { set32(8, EsdId); }
+
+  void setOffset(uint32_t Offset) { set32(16, Offset); }
+
+  void setLength(uint32_t Length) { set32(24, Length); }
+
+  void setNameSpaceId(GOFF::ESDNameSpaceId Id) { set8(40, Id); }
+
+  void setFillBytePresent(bool Present) { setBits(41, 0, 1, Present); }
+
+  void setNameMangled(bool Mangled) { setBits(41, 1, 1, Mangled); }
+
+  void setRenamable(bool Renamable) { setBits(41, 2, 1, Renamable); }
+
+  void setRemovable(bool Removable) { setBits(41, 3, 1, Removable); }
+
+  void setReserveQwords(GOFF::ESDReserveQwords Reserve) {
+    setBits(41, 5, 3, Reserve);
+  }
+
+  // This intentionally uses the same field as above
+  void setERSymbolType(GOFF::ESDERSymbolType Type) { setBits(41, 5, 3, Type); }
+
+  void setFillByteValue(uint8_t Fill) { set8(42, Fill); }
+
+  void setAdaEsdId(uint32_t EsdId) { set32(44, EsdId); }
+
+  void setSortPriority(uint32_t Priority) { set32(48, Priority); }
+
+  void setAmode(GOFF::ESDAmode Amode) { set8(60, Amode); }
+
+  void setRmode(GOFF::ESDRmode Rmode) { set8(61, Rmode); }
+
+  void setTextStyle(GOFF::ESDTextStyle Style) { setBits(62, 0, 4, Style); }
+
+  void setBindingAlgorithm(GOFF::ESDBindingAlgorithm Algorithm) {
+    setBits(62, 4, 4, Algorithm);
+  }
+
+  void setTaskingBehavior(GOFF::ESDTaskingBehavior TaskingBehavior) {
+    setBits(63, 0, 3, TaskingBehavior);
+  }
+
+  void setReadOnly(bool ReadOnly) {
+    uint8_t Value = ReadOnly ? 1 : 0;
+    setBits(63, 4, 1, Value);
+  }
+
+  void setExecutable(GOFF::ESDExecutable Executable) {
+    setBits(63, 5, 3, Executable);
+  }
+
+  void setDuplicateSeverity(GOFF::ESDDuplicateSymbolSeverity DSS) {
+    setBits(64, 2, 2, DSS);
+  }
+
+  void setBindingStrength(GOFF::ESDBindingStrength Strength) {
+    setBits(64, 4, 4, Strength);
+  }
+
+  void setLoadingBehavior(GOFF::ESDLoadingBehavior Behavior) {
+    setBits(65, 0, 2, Behavior);
+  }
+
+  void setIndirectReference(bool Indirect) {
+    uint8_t Value = Indirect ? 1 : 0;
+    setBits(65, 3, 1, Value);
+  }
+
+  void setBindingScope(GOFF::ESDBindingScope Scope) {
+    setBits(65, 4, 4, Scope);
+  }
+
+  void setLinkageType(GOFF::ESDLinkageType Type) { setBits(66, 2, 1, Type); }
+
+  void setAlignment(GOFF::ESDAlignment Alignment) {
+    setBits(66, 3, 5, Alignment);
+  }
+
+  void setNameLength(uint16_t Length) { set16(70, Length); }
+
+  void setName(const StringRef::const_iterator &Data, uint8_t Length) {
+    assert(Length <= ESDMaxNameLength && "Data too long for ESD Record");
+
+    for (int I = 0; I < Length; ++I)
+      set8(72 + I, Data[I]);
+  }
+
+  // ESD Get routines
+  static void getSymbolType(const uint8_t *Record,
+                            GOFF::ESDSymbolType &SymbolType) {
+    uint8_t Value;
+    get8(Record, 3, Value);
+    SymbolType = (GOFF::ESDSymbolType)Value;
+  }
+
+  static void getEsdId(const uint8_t *Record, uint32_t &EsdId) {
+    get32(Record, 4, EsdId);
+  }
+
+  static void getParentEsdId(const uint8_t *Record, uint32_t &EsdId) {
+    get32(Record, 8, EsdId);
+  }
+
+  static void getOffset(const uint8_t *Record, uint32_t &Offset) {
+    get32(Record, 16, Offset);
+  }
+
+  static void getLength(const uint8_t *Record, uint32_t &Length) {
+    get32(Record, 24, Length);
+  }
+
+  static void getNameSpaceId(const uint8_t *Record, GOFF::ESDNameSpaceId &Id) {
+    uint8_t Value;
+    get8(Record, 40, Value);
+    Id = (GOFF::ESDNameSpaceId)Value;
+  }
+
+  static void getFillBytePresent(const uint8_t *Record, bool &Present) {
+    uint8_t Value;
+    getBits(Record, 41, 0, 1, Value);
+    Present = (bool)Value;
+  }
+
+  static void getNameMangled(const uint8_t *Record, bool &Mangled) {
+    uint8_t Value;
+    getBits(Record, 41, 1, 1, Value);
+    Mangled = (bool)Value;
+  }
+
+  static void getRenamable(const uint8_t *Record, bool &Renamable) {
+    uint8_t Value;
+    getBits(Record, 41, 2, 1, Value);
+    Renamable = (bool)Value;
+  }
+
+  static void getRemovable(const uint8_t *Record, bool &Removable) {
+    uint8_t Value;
+    getBits(Record, 41, 3, 1, Value);
+    Removable = (bool)Value;
+  }
+
+  // This intentionally uses the same field as above
+  static void getERSymbolType(const uint8_t *Record,
+                              GOFF::ESDERSymbolType &Type) {
+    uint8_t Value;
+    getBits(Record, 41, 5, 3, Value);
+    Type = (GOFF::ESDERSymbolType)Value;
+  }
+
+  static void getFillByteValue(const uint8_t *Record, uint8_t &Fill) {
+    get8(Record, 42, Fill);
+  }
+
+  static void getAdaEsdId(const uint8_t *Record, uint32_t &EsdId) {
+    get32(Record, 44, EsdId);
+  }
+
+  static void getSortPriority(const uint8_t *Record, uint32_t &Priority) {
+    get32(Record, 48, Priority);
+  }
+
+  static void getAmode(const uint8_t *Record, GOFF::ESDAmode &Amode) {
+    uint8_t Value;
+    get8(Record, 60, Value);
+    Amode = (GOFF::ESDAmode)Value;
+  }
+
+  static void getRmode(const uint8_t *Record, GOFF::ESDRmode &Rmode) {
+    uint8_t Value;
+    get8(Record, 61, Value);
+    Rmode = (GOFF::ESDRmode)Value;
+  }
+
+  static void getTextStyle(const uint8_t *Record, GOFF::ESDTextStyle &Style) {
+    uint8_t Value;
+    getBits(Record, 62, 0, 4, Value);
+    Style = (GOFF::ESDTextStyle)Value;
+  }
+
+  static void getBindingAlgorithm(const uint8_t *Record,
+                                  GOFF::ESDBindingAlgorithm &Algorithm) {
+    uint8_t Value;
+    getBits(Record, 62, 4, 4, Value);
+    Algorithm = (GOFF::ESDBindingAlgorithm)Value;
+  }
+
+  static void getTaskingBehavior(const uint8_t *Record,
+                                 GOFF::ESDTaskingBehavior &TaskingBehavior) {
+    uint8_t Value;
+    getBits(Record, 63, 0, 3, Value);
+    TaskingBehavior = (GOFF::ESDTaskingBehavior)Value;
+  }
+
+  static void getReadOnly(const uint8_t *Record, bool &ReadOnly) {
+    uint8_t Value;
+    getBits(Record, 63, 4, 1, Value);
+    ReadOnly = (bool)Value;
+  }
+
+  static void getExecutable(const uint8_t *Record,
+                            GOFF::ESDExecutable &Executable) {
+    uint8_t Value;
+    getBits(Record, 63, 5, 3, Value);
+    Executable = (GOFF::ESDExecutable)Value;
+  }
+
+  static void getDuplicateSeverity(const uint8_t *Record,
+                                   GOFF::ESDDuplicateSymbolSeverity &DSS) {
+    uint8_t Value;
+    getBits(Record, 64, 2, 2, Value);
+    DSS = (GOFF::ESDDuplicateSymbolSeverity)Value;
+  }
+
+  static void getBindingStrength(const uint8_t *Record,
+                                 GOFF::ESDBindingStrength &Strength) {
+    uint8_t Value;
+    getBits(Record, 64, 4, 4, Value);
+    Strength = (GOFF::ESDBindingStrength)Value;
+  }
+
+  static void getLoadingBehavior(const uint8_t *Record,
+                                 GOFF::ESDLoadingBehavior &Behavior) {
+    uint8_t Value;
+    getBits(Record, 65, 0, 2, Value);
+    Behavior = (GOFF::ESDLoadingBehavior)Value;
+  }
+
+  static void getIndirectReference(const uint8_t *Record, bool &Indirect) {
+    uint8_t Value;
+    getBits(Record, 65, 3, 1, Value);
+    Indirect = (bool)Value;
+  }
+
+  static void getBindingScope(const uint8_t *Record,
+                              GOFF::ESDBindingScope &Scope) {
+    uint8_t Value;
+    getBits(Record, 65, 4, 4, Value);
+    Scope = (GOFF::ESDBindingScope)Value;
+  }
+
+  static void getLinkageType(const uint8_t *Record,
+                             GOFF::ESDLinkageType &Type) {
+    uint8_t Value;
+    getBits(Record, 66, 2, 1, Value);
+    Type = (GOFF::ESDLinkageType)Value;
+  }
+
+  static void getAlignment(const uint8_t *Record,
+                           GOFF::ESDAlignment &Alignment) {
+    uint8_t Value;
+    getBits(Record, 66, 3, 5, Value);
+    Alignment = (GOFF::ESDAlignment)Value;
+  }
+};
+
+class RLDRecord : public Record {
+public:
+  /// \brief Maximum length of data; any more must go in another continuation.
+  static const uint8_t RLDMaxDataLength = 74;
+
+  /// \brief Lenght in bytes of one full relocation entry. We don't pack EsdIds.
+  static const uint8_t DataEntryLength = 20;
+
+public:
+  RLDRecord() : Record() { setRecordType(GOFF::RT_RLD); }
+
+  void setLength(uint16_t Length) { set16(4, Length); }
+
+  void setData(const GOFFRelocationEntry &Ent, uint8_t Index) {
+    assert(Index < 2 && "Can only store two entries per RLD Record");
+
+    uint8_t Offset = 6 + DataEntryLength * Index;
+
+    setBits(Offset + 1, 0, 4, Ent.ReferenceType);
+    setBits(Offset + 1, 4, 4, Ent.ReferentType);
+    setBits(Offset + 2, 0, 7, Ent.Action);
+    if (Ent.NoFetchTarget)
+      setBits(Offset + 2, 7, 1, 1);
+    else
+      setBits(Offset + 2, 7, 1, 0);
+    set8(Offset + 4, Ent.TargetLength);
+    set32(Offset + 8, Ent.REsdId);
+    set32(Offset + 12, Ent.PEsdId);
+    set32(Offset + 16, Ent.POffset);
+  }
+
+  // RLD Get routines
+  static void getLength(const uint8_t *Record, uint16_t &Length) {
+    get16(Record, 4, Length);
+  }
+};
+
+class ContinuationRecord : public Record {
+public:
+  /// \brief Maximum length of data; any more must go in another continuation.
+  static const uint8_t ContinuationMaxDataLength = 77;
+
+public:
+  ContinuationRecord(GOFF::RecordType Type) : Record() {
+    setRecordType(Type);
+    setContinuation(true);
+  }
+
+  // As it stands we call this function with both of these iterators and they
+  // both just happen to be typedef'd to char*. If the underlying implementation
+  // ever changes then these overloads should be used.
+  // void setData(const SmallVectorImpl<char>::const_iterator &Data,
+  //             uint8_t Length);
+  // void setData(const StringRef::const_iterator &Data, uint8_t Length);
+  void setData(const char *Data, uint8_t Length) {
+    assert(Length <= ContinuationMaxDataLength &&
+           "Data too long for Continuation Record");
+
+    for (int I = 0; I < Length; ++I)
+      set8(3 + I, Data[I]);
+  }
+};
+
+class ENDRecord : public Record {
+public:
+  ENDRecord() : Record() {
+    setRecordType(GOFF::RT_END);
+    setEntryPointRequestType(GOFF::END_EPR_None); // TODO Always None for now
+  }
+
+  void setEntryPointRequestType(GOFF::ENDEntryPointRequest Eprt) {
+    setBits(3, 6, 2, Eprt);
+  }
+
+  void setEntryAmode(GOFF::ESDAmode Amode) { set8(4, Amode); }
+
+  void setEntryEsdId(uint32_t EsdId) { set32(12, EsdId); }
+
+  void setRecordCount(uint32_t RecordCount) { set32(8, RecordCount); }
+};
+
+} // end namespace object
+} // end namespace llvm
+
+#endif

llvm/include/llvm/Object/GOFFObjectFile.h

+//===- GOFF.h - GOFF object file implementation -----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the GOFFObjectFile class.
+// Record classes and derivatives are also declared and implemented.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_GOFFOBJECTFILE_H
+#define LLVM_OBJECT_GOFFOBJECTFILE_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/IndexedMap.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/BinaryFormat/GOFF.h"
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/CharSet.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+namespace object {
+
+class GOFFObjectFile : public ObjectFile {
+
+  IndexedMap<uintptr_t> EsdPtrs; // indexed by EsdId
+  SmallVector<uintptr_t, 256> TextPtrs;
+  SmallVector<uintptr_t, 256> RldPtrs;
+
+  mutable DenseMap<uint32_t, std::string> EsdNames;
+
+  typedef DataRefImpl SectionEntryImpl;
+  // (EDID, 0)               code, r/o data section
+  // (EDID,PRID)             r/w data section
+  SmallVector<SectionEntryImpl, 256> SectionList;
+  mutable DenseMap<uint32_t, std::string> SectionData;
+
+  std::string RelocationData;
+
+  CharSetConverter Converter;
+
+protected:
+  // SymbolRef
+  Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
+  Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
+  uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
+  uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
+  Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
+  Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
+  Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
+
+  // GOFF specific
+public:
+  DataRefImpl getAdaSymbolOfSymbol(DataRefImpl Symb) const;
+  std::error_code getSymbolName(SymbolRef Symbol, StringRef &Res) const;
+
+private:
+  const uint8_t *getSymbolEsdRecord(DataRefImpl Symb) const;
+  bool isSymbolUnresolved(DataRefImpl Symb) const;
+  bool isSymbolIndirect(DataRefImpl Symb) const;
+
+protected:
+  // SectionRef
+  void moveSectionNext(DataRefImpl &Sec) const override;
+  virtual Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
+  uint64_t getSectionAddress(DataRefImpl Sec) const override;
+  uint64_t getSectionSize(DataRefImpl Sec) const override;
+  virtual Expected<ArrayRef<uint8_t>>
+  getSectionContents(DataRefImpl Sec) const override;
+  uint64_t getSectionIndex(DataRefImpl Sec) const override;
+  uint64_t getSectionAlignment(DataRefImpl Sec) const override;
+  bool isSectionCompressed(DataRefImpl Sec) const override;
+  bool isSectionText(DataRefImpl Sec) const override;
+  bool isSectionData(DataRefImpl Sec) const override;
+  bool isSectionBSS(DataRefImpl Sec) const override;
+  bool isSectionVirtual(DataRefImpl Sec) const override;
+  relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
+  relocation_iterator section_rel_end(DataRefImpl Sec) const override;
+
+  // GOFF specific
+public:
+  bool isSectionNoLoad(DataRefImpl Sec) const;
+  bool isSectionReadOnlyData(DataRefImpl Sec) const;
+  bool isSectionZeroInit(DataRefImpl Sec) const;
+
+private:
+  const uint8_t *getSectionEdEsdRecord(DataRefImpl &Sec) const;
+  const uint8_t *getSectionPrEsdRecord(DataRefImpl &Sec) const;
+  const uint8_t *getSectionEdEsdRecord(uint32_t SectionIndex) const;
+  const uint8_t *getSectionPrEsdRecord(uint32_t SectionIndex) const;
+  uint32_t getSectionDefEsdId(DataRefImpl &Sec) const;
+
+  typedef struct {
+    //// == common output
+    DataRefImpl Sec;         // section containing relocation
+    uint64_t PosOffset;      // offset of relocation in Sec
+    DataRefImpl RefSymb;     // symbol referred to
+    uint64_t RelocationType; // type of relocation
+
+    //// === fields used when processing relocations from object file
+    uint32_t RelocationDataOffset;
+    uint16_t CurrentRldSize;
+
+    uint32_t SectionDefId;
+
+    // Optional RLD fields whose value is inherited from a previous RLD item
+    uint32_t OReferenceId;
+    uint32_t OPositionId;
+    uint64_t OOffset;
+
+    //// === fields when processing relocations for manufactured function
+    /// descriptor section
+    uint32_t FunctionDescriptorIndex;
+    bool DoingFuncSymb;
+  } RelocationIteratorState_t;
+
+protected:
+  // RelocationRef
+  void moveRelocationNext(DataRefImpl &Rel) const override;
+  uint64_t getRelocationOffset(DataRefImpl Rel) const override;
+  symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
+  uint64_t getRelocationType(DataRefImpl Rel) const override;
+  void getRelocationTypeName(DataRefImpl Rel,
+                             SmallVectorImpl<char> &Result) const override;
+  // GOFF specific
+public:
+  static GOFF::RLDReferenceType getRLDReferenceType(uint64_t RelocationType);
+  static GOFF::RLDAction getRLDAction(uint64_t RelocationType); // +,-,...
+  static GOFF::RLDFetchStore getRLDFetchStore(uint64_t RelocationType);
+  static uint16_t getRLDBitLength(uint64_t RelocationType);
+  static uint8_t getRLDBitOffset(uint64_t RelocationType);
+  static bool
+  getRLDSymbolIsIndirect(uint64_t RelocationType);   // function descriptor ref
+  static bool getRLDIsWeak(uint64_t RelocationType); // weak ref
+  static bool
+  getRLDIsCodeAddressReference(uint64_t RelocationType); // function code ref
+  static uint32_t getNormalRelocationType(uint8_t PointerSizeInBytes);
+
+  static uint8_t getBytesInFunctionDescriptor() { return 16; } // XPLink 64
+
+private:
+  void getRelocationData();
+
+protected:
+public:
+  GOFFObjectFile(MemoryBufferRef Object, std::error_code &EC);
+  static inline bool classof(const Binary *V) { return V->isGOFF(); }
+  section_iterator section_begin() const override;
+  section_iterator section_end() const override;
+
+  uint8_t getBytesInAddress() const override { return 8; }
+
+  StringRef getFileFormatName() const override { return "GOFF-SystemZ"; }
+
+  Triple::ArchType getArch() const override { return Triple::systemz; }
+
+  SubtargetFeatures getFeatures() const override { return SubtargetFeatures(); }
+
+  bool isRelocatableObject() const override { return true; }
+
+  void moveSymbolNext(DataRefImpl &Symb) const override;
+  basic_symbol_iterator symbol_begin() const override;
+  basic_symbol_iterator symbol_end() const override;
+};
+
+} // namespace object
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/Object/ObjectFile.h

 //===- ObjectFile.h - File format independent object file -------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
public:
   static Expected<std::unique_ptr<ObjectFile>>
   createELFObjectFile(MemoryBufferRef Object);
 
   static Expected<std::unique_ptr<MachOObjectFile>>
   createMachOObjectFile(MemoryBufferRef Object,
                         uint32_t UniversalCputype = 0,
                         uint32_t UniversalIndex = 0);
 
+  static Expected<std::unique_ptr<ObjectFile>>
+  createGOFFObjectFile(MemoryBufferRef Object);
+
   static Expected<std::unique_ptr<WasmObjectFile>>
   createWasmObjectFile(MemoryBufferRef Object);
 };
 
 // Inline function definitions.
 inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner)
     : BasicSymbolRef(SymbolP, Owner) {}
 

llvm/lib/BinaryFormat/Magic.cpp

 //===- llvm/BinaryFormat/Magic.cpp - File magic identification --*- 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
 //
 //===----------------------------------------------------------------------===//
 
file_magic llvm::identify_magic(StringRef Magic) {
   case 'B':
     if (startswith(Magic, "BC\xC0\xDE"))
       return file_magic::bitcode;
     break;
   case '!':
     if (startswith(Magic, "!<arch>\n") || startswith(Magic, "!<thin>\n"))
       return file_magic::archive;
     break;
-
+  case 0x03:
+    if (startswith(Magic, "\x03\xF0\x00"))
+      return file_magic::goff_object;
+    break;
   case '\177':
     if (startswith(Magic, "\177ELF") && Magic.size() >= 18) {
       bool Data2MSB = Magic[5] == 2;
       unsigned high = Data2MSB ? 16 : 17;
       unsigned low = Data2MSB ? 17 : 16;
       if (Magic[high] == 0) {
         switch (Magic[low]) {
         default:

llvm/lib/Object/Binary.cpp

 //===- Binary.cpp - A generic binary file ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
Expected<std::unique_ptr<Binary>> object::createBinary(MemoryBufferRef Buffer,
   case file_magic::macho_preload_executable:
   case file_magic::macho_dynamically_linked_shared_lib:
   case file_magic::macho_dynamic_linker:
   case file_magic::macho_bundle:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::macho_dsym_companion:
   case file_magic::macho_kext_bundle:
   case file_magic::coff_object:
   case file_magic::coff_import_library:
+  case file_magic::goff_object:
   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);

llvm/lib/Object/CMakeLists.txt

 add_llvm_component_library(LLVMObject
   Archive.cpp
   ArchiveWriter.cpp
   Binary.cpp
   COFFImportFile.cpp
   COFFModuleDefinition.cpp
   COFFObjectFile.cpp
   Decompressor.cpp
   ELF.cpp
   ELFObjectFile.cpp
   Error.cpp
+  GOFFObjectFile.cpp
   IRObjectFile.cpp
   IRSymtab.cpp
   MachOObjectFile.cpp
   MachOUniversal.cpp
   Minidump.cpp
   ModuleSymbolTable.cpp
   Object.cpp
   ObjectFile.cpp

llvm/lib/Object/GOFFObjectFile.cpp

+//===- GOFFObjectFile.cpp - GOFF object file implementation -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of the GOFFObjectFile class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/GOFFObjectFile.h"
+#include "llvm/BinaryFormat/GOFF.h"
+#include "llvm/Object/GOFF.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+#ifndef DEBUG_TYPE
+#define DEBUG_TYPE "goff"
+#endif
+
+using namespace llvm;
+using namespace object;
+
+Expected<std::unique_ptr<ObjectFile>>
+ObjectFile::createGOFFObjectFile(MemoryBufferRef Object) {
+  std::error_code EC;
+  std::unique_ptr<GOFFObjectFile> Ret(new GOFFObjectFile(Object, EC));
+  if (EC)
+    return make_error<StringError>("Unexpected EOF", EC);
+  return std::move(Ret);
+}
+
+GOFFObjectFile::GOFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
+    : ObjectFile(Binary::ID_GOFF, Object),
+      Converter(cantFail(errorOrToExpected(CharSetConverter::create(
+          CharSetConverter::CP_IBM1047, CharSetConverter::CP_UTF8)))) {
+  // Object file isn't the right size, bail out early
+  if ((Object.getBufferSize() % GOFF::RecordLength) != 0) {
+    EC = make_error_code(object_error::unexpected_eof);
+    return;
+  }
+
+  SectionEntryImpl DummySection;
+  SectionList.emplace_back(DummySection); // dummy entry at index 0
+
+  const uint8_t *End = reinterpret_cast<const uint8_t *>(Data.getBufferEnd());
+  for (const uint8_t *I = base(); I < End; I += GOFF::RecordLength) {
+    uint8_t RecordType = (I[1] & 0xF0) >> 4;
+    bool IsContinuation = I[1] & 0x02;
+
+    // Don't parse continuations records, they've already been handled by
+    // a previous record parse call
+    if (IsContinuation)
+      continue;
+
+    for (size_t J = 0; J < GOFF::RecordLength; ++J) {
+      const uint8_t *P = I + J;
+      if (J % 8 == 0)
+        LLVM_DEBUG(dbgs() << "  ");
+
+      LLVM_DEBUG(dbgs() << format("%02hhX", *P));
+    }
+    switch (RecordType) {
+    case GOFF::RT_ESD: {
+      // Save ESD record
+      uint32_t EsdId;
+      ESDRecord::getEsdId(I, EsdId);
+      EsdPtrs.grow(EsdId);
+      EsdPtrs[EsdId] = reinterpret_cast<uintptr_t>(I);
+
+      // Determine and save the "sections" in GOFF.
+      // A section is saved as a tuple of the form
+      // case (1): (ED,child PR)
+      //    - where the PR must be have non-zero length.
+      // case (2a) (ED,0)
+      //   - where the ED is of non-zero length
+      // case (2b) (ED,0)
+      //   - where the ED is zero length but
+      //     but contains a label (LD)
+      GOFF::ESDSymbolType SymbolType;
+      ESDRecord::getSymbolType(I, SymbolType);
+      SectionEntryImpl Section;
+      uint32_t Length;
+      ESDRecord::getLength(I, Length);
+      if (SymbolType == GOFF::ESD_ST_ElementDefinition) {
+        // case (2a)
+        if (Length != 0) {
+          Section.d.a = EsdId;
+          SectionList.emplace_back(Section);
+        }
+      } else if (SymbolType == GOFF::ESD_ST_PartReference) {
+        // case (1)
+        if (Length != 0) {
+          uint32_t SymEdId;
+          ESDRecord::getParentEsdId(I, SymEdId);
+          Section.d.a = SymEdId;
+          Section.d.b = EsdId;
+          SectionList.emplace_back(Section);
+        }
+      } else if (SymbolType == GOFF::ESD_ST_LabelDefinition) {
+        // case (2b)
+        uint32_t SymEdId;
+        ESDRecord::getParentEsdId(I, SymEdId);
+        const uint8_t *SymEdRecord =
+            reinterpret_cast<const uint8_t *>(EsdPtrs[SymEdId]);
+        uint32_t EdLength;
+        ESDRecord::getLength(SymEdRecord, EdLength);
+        if (!EdLength) { // [ EDID, PRID ]
+          // LD child of a zero length parent ED
+          // Add the section ED which was previously ignored
+          Section.d.a = SymEdId;
+          SectionList.emplace_back(Section);
+        }
+      }
+      LLVM_DEBUG(dbgs() << "  --  ESD " << EsdId << "\n");
+      break;
+    }
+    case GOFF::RT_TXT:
+      // Save TXT records
+      TextPtrs.emplace_back(reinterpret_cast<uintptr_t>(I));
+      LLVM_DEBUG(dbgs() << "  --  TXT\n");
+      break;
+    case GOFF::RT_RLD:
+      // Save RLD records
+      RldPtrs.emplace_back(reinterpret_cast<uintptr_t>(I));
+      LLVM_DEBUG(dbgs() << "  --  RLD\n");
+      break;
+    case GOFF::RT_LEN:
+      LLVM_DEBUG(dbgs() << "  --  LEN (GOFF record type) unhandled\n");
+      break;
+    case GOFF::RT_END:
+      LLVM_DEBUG(dbgs() << "  --  END (GOFF record type) unhandled\n");
+      break;
+    case GOFF::RT_HDR:
+      LLVM_DEBUG(dbgs() << "  --  HDR (GOFF record type) unhandled\n");
+      break;
+    default:
+      llvm_unreachable("Unknown record type");
+    }
+  }
+
+  getRelocationData();
+}
+
+// SymbolRef
+DataRefImpl GOFFObjectFile::getAdaSymbolOfSymbol(DataRefImpl Symb) const {
+  const uint8_t *EsdRecord = getSymbolEsdRecord(Symb);
+  uint32_t AdaId;
+  ESDRecord::getAdaEsdId(EsdRecord, AdaId); // use as function indicator
+  DataRefImpl AdaSymb;
+  AdaSymb.d.a = AdaId;
+  return AdaSymb;
+}
+const uint8_t *GOFFObjectFile::getSymbolEsdRecord(DataRefImpl Symb) const {
+  const uint8_t *EsdRecord =
+      reinterpret_cast<const uint8_t *>(EsdPtrs[Symb.d.a]);
+  return EsdRecord;
+}
+Expected<StringRef> GOFFObjectFile::getSymbolName(DataRefImpl Symb) const {
+  if (EsdNames.count(Symb.d.a))
+    return EsdNames[Symb.d.a];
+
+  const char *Record = (const char *)getSymbolEsdRecord(Symb);
+
+  // TODO: This could probably be changed to extract the length of the symbol
+  // name and then grab only that many characters but for now this works fine
+  uint16_t Continuations = 0;
+  while (true) {
+    // Is the record continued in the next record
+    const char *ContinuationByte =
+        Record + (Continuations * GOFF::RecordLength) + 1;
+    bool IsContinued = *ContinuationByte & 0x01;
+
+    if (IsContinued)
+      ++Continuations;
+    else
+      break;
+  }
+
+  SmallString<256> SymbolName(Record + 72, Record + GOFF::RecordLength);
+
+  // This assumes that we always emit 80 byte records even if the rest of the
+  // data in a record is nulls
+  for (uint16_t I = 0; I < Continuations; ++I) {
+    const char *ContRecord = Record + (GOFF::RecordLength * (I + 1));
+    SymbolName.append(ContRecord + 3, ContRecord + GOFF::RecordLength);
+  }
+
+  SmallString<256> SymbolNameConverted;
+  if (auto EC = Converter.convert(SymbolName, SymbolNameConverted))
+    return errorCodeToError(EC);
+  EsdNames[Symb.d.a].assign(SymbolNameConverted.c_str());
+  return EsdNames[Symb.d.a];
+}
+
+std::error_code GOFFObjectFile::getSymbolName(SymbolRef Symbol,
+                                              StringRef &Res) const {
+  Expected<StringRef> NameOrErr = getSymbolName(Symbol.getRawDataRefImpl());
+  if (NameOrErr) {
+    Res = *NameOrErr;
+    return std::error_code();
+  }
+  return errorToErrorCode(NameOrErr.takeError());
+}
+
+Expected<uint64_t> GOFFObjectFile::getSymbolAddress(DataRefImpl Symb) const {
+  uint32_t Offset;
+  const uint8_t *EsdRecord = getSymbolEsdRecord(Symb);
+  ESDRecord::getOffset(EsdRecord, Offset);
+  return static_cast<uint64_t>(Offset);
+}
+
+uint64_t GOFFObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
+  uint32_t Offset;
+  const uint8_t *EsdRecord = getSymbolEsdRecord(Symb);
+  ESDRecord::getOffset(EsdRecord, Offset);
+  return static_cast<uint64_t>(Offset);
+}
+
+uint64_t GOFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
+  return 0;
+}
+
+bool GOFFObjectFile::isSymbolUnresolved(DataRefImpl Symb) const {
+  const uint8_t *Record = getSymbolEsdRecord(Symb);
+  GOFF::ESDSymbolType SymbolType;
+  ESDRecord::getSymbolType(Record, SymbolType);
+
+  if (SymbolType == GOFF::ESD_ST_ExternalReference)
+    return true;
+  if (SymbolType == GOFF::ESD_ST_PartReference) {
+    uint32_t Length;
+    ESDRecord::getLength(Record, Length);
+    if (Length == 0)
+      return true;
+  }
+  return false;
+}
+
+bool GOFFObjectFile::isSymbolIndirect(DataRefImpl Symb) const {
+  const uint8_t *Record = getSymbolEsdRecord(Symb);
+  bool Indirect;
+  ESDRecord::getIndirectReference(Record, Indirect);
+  return Indirect;
+}
+
+Expected<uint32_t> GOFFObjectFile::getSymbolFlags(DataRefImpl Symb) const {
+  uint32_t Flags = 0;
+  if (isSymbolUnresolved(Symb))
+    Flags |= SymbolRef::SF_Undefined;
+
+  const uint8_t *Record = getSymbolEsdRecord(Symb);
+
+  GOFF::ESDBindingStrength BindingStrength;
+  ESDRecord::getBindingStrength(Record, BindingStrength);
+  if (BindingStrength == GOFF::ESD_BST_Weak)
+    Flags |= SymbolRef::SF_Weak;
+
+  GOFF::ESDBindingScope BindingScope;
+  ESDRecord::getBindingScope(Record, BindingScope);
+
+  if (BindingScope != GOFF::ESD_BSC_Section) {
+    Expected<StringRef> Name = getSymbolName(Symb);
+    if (Name && !Name->equals(" ")) { // blank name is local
+      Flags |= SymbolRef::SF_Global;
+      if (BindingScope == GOFF::ESD_BSC_ImportExport)
+        Flags |= SymbolRef::SF_Exported;
+      else if (!(Flags & SymbolRef::SF_Undefined))
+        Flags |= SymbolRef::SF_Hidden;
+    }
+  }
+
+  return Flags;
+}
+
+Expected<SymbolRef::Type>
+GOFFObjectFile::getSymbolType(DataRefImpl Symb) const {
+  const uint8_t *Record = getSymbolEsdRecord(Symb);
+  GOFF::ESDSymbolType SymbolType;
+  ESDRecord::getSymbolType(Record, SymbolType);
+  GOFF::ESDExecutable Executable;
+  ESDRecord::getExecutable(Record, Executable);
+
+  assert((SymbolType == GOFF::ESD_ST_SectionDefinition ||
+          SymbolType == GOFF::ESD_ST_ElementDefinition ||
+          SymbolType == GOFF::ESD_ST_LabelDefinition ||
+          SymbolType == GOFF::ESD_ST_PartReference ||
+          SymbolType == GOFF::ESD_ST_ExternalReference) &&
+         "SymbolType must be SectionDef/ElemDef/LabelDef/PartRef/ExtRef");
+
+  switch (SymbolType) {
+  case GOFF::ESD_ST_SectionDefinition:
+  case GOFF::ESD_ST_ElementDefinition:
+    return SymbolRef::ST_Other;
+  case GOFF::ESD_ST_LabelDefinition:
+  case GOFF::ESD_ST_PartReference:
+  case GOFF::ESD_ST_ExternalReference:
+    assert((Executable == GOFF::ESD_EXE_CODE ||
+            Executable == GOFF::ESD_EXE_DATA ||
+            Executable == GOFF::ESD_EXE_Unspecified) &&
+           "Executable must be CODE/DATA/Unspecified");
+    switch (Executable) {
+    case GOFF::ESD_EXE_CODE:
+      return SymbolRef::ST_Function;
+    case GOFF::ESD_EXE_DATA:
+      return SymbolRef::ST_Data;
+    case GOFF::ESD_EXE_Unspecified:
+      return SymbolRef::ST_Unknown;
+    }
+  }
+}
+
+Expected<section_iterator>
+GOFFObjectFile::getSymbolSection(DataRefImpl Symb) const {
+  DataRefImpl Sec;
+
+  if (isSymbolUnresolved(Symb))
+    return section_iterator(SectionRef(Sec, this));
+
+  const uint8_t *SymEsdRecord =
+      reinterpret_cast<const uint8_t *>(EsdPtrs[Symb.d.a]);
+  uint32_t SymEdId;
+  ESDRecord::getParentEsdId(SymEsdRecord, SymEdId);
+  const uint8_t *SymEdRecord =
+      reinterpret_cast<const uint8_t *>(EsdPtrs[SymEdId]);
+
+  for (size_t I = 0; I < SectionList.size(); ++I) {
+    bool Found;
+    const uint8_t *SectionPrRecord = getSectionPrEsdRecord(I);
+    if (SectionPrRecord) {
+      Found = SymEsdRecord == SectionPrRecord;
+    } else {
+      const uint8_t *SectionEdRecord = getSectionEdEsdRecord(I);
+      Found = SymEdRecord == SectionEdRecord;
+    }
+
+    if (Found) {
+      Sec.d.a = I;
+      return section_iterator(SectionRef(Sec, this));
+    }
+  }
+  llvm_unreachable("unable to get symbol section");
+  return section_iterator(SectionRef(Sec, this));
+}
+
+// SectionRef
+const uint8_t *GOFFObjectFile::getSectionEdEsdRecord(DataRefImpl &Sec) const {
+  SectionEntryImpl EsdIds = SectionList[Sec.d.a];
+  const uint8_t *EsdRecord =
+      reinterpret_cast<const uint8_t *>(EsdPtrs[EsdIds.d.a]);
+  return EsdRecord;
+}
+
+const uint8_t *GOFFObjectFile::getSectionPrEsdRecord(DataRefImpl &Sec) const {
+  SectionEntryImpl EsdIds = SectionList[Sec.d.a];
+  const uint8_t *EsdRecord = NULL;
+  if (EsdIds.d.b)
+    EsdRecord = reinterpret_cast<const uint8_t *>(EsdPtrs[EsdIds.d.b]);
+  return EsdRecord;
+}
+const uint8_t *
+GOFFObjectFile::getSectionEdEsdRecord(uint32_t SectionIndex) const {
+  DataRefImpl Sec;
+  Sec.d.a = SectionIndex;
+  const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+  return EsdRecord;
+}
+const uint8_t *
+GOFFObjectFile::getSectionPrEsdRecord(uint32_t SectionIndex) const {
+  DataRefImpl Sec;
+  Sec.d.a = SectionIndex;
+  const uint8_t *EsdRecord = getSectionPrEsdRecord(Sec);
+  return EsdRecord;
+}
+
+uint32_t GOFFObjectFile::getSectionDefEsdId(DataRefImpl &Sec) const {
+  const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+  uint32_t Length;
+  ESDRecord::getLength(EsdRecord, Length);
+  if (Length == 0) {
+    const uint8_t *PrEsdRecord = getSectionPrEsdRecord(Sec);
+    if (PrEsdRecord)
+      EsdRecord = PrEsdRecord;
+  }
+
+  uint32_t DefEsdId;
+  ESDRecord::getEsdId(EsdRecord, DefEsdId);
+  LLVM_DEBUG(dbgs() << "Got def EsdId: " << DefEsdId << '\n');
+  return DefEsdId;
+}
+
+void GOFFObjectFile::moveSectionNext(DataRefImpl &Sec) const {
+  if ((Sec.d.a + 1) >= SectionList.size())
+    Sec.d.a = 0; // section_end
+  else
+    Sec.d.a++;
+}
+
+Expected<StringRef> GOFFObjectFile::getSectionName(DataRefImpl Sec) const {
+  DataRefImpl EdSym;
+  SectionEntryImpl EsdIds = SectionList[Sec.d.a];
+  EdSym.d.a = EsdIds.d.a;
+  Expected<StringRef> Name = getSymbolName(EdSym);
+  if (Name) {
+    StringRef Res = *Name;
+    LLVM_DEBUG(dbgs() << "Got section: " << Res << '\n');
+    if (Res.equals("C___clangast"))
+      Res = "__clangast";
+    else if (Res.equals("C_autolink"))
+      Res = ".swift1_autolink_entries";
+    LLVM_DEBUG(dbgs() << "Final section name: " << Res << '\n');
+    Name = Res;
+  }
+  return Name;
+}
+
+uint64_t GOFFObjectFile::getSectionAddress(DataRefImpl Sec) const {
+  uint32_t Offset;
+  const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+  ESDRecord::getOffset(EsdRecord, Offset);
+  return Offset;
+}
+
+uint64_t GOFFObjectFile::getSectionIndex(DataRefImpl Sec) const {
+  return Sec.d.a;
+}
+
+uint64_t GOFFObjectFile::getSectionSize(DataRefImpl Sec) const {
+  uint32_t Length;
+  uint32_t DefEsdId = getSectionDefEsdId(Sec);
+  const uint8_t *EsdRecord =
+      reinterpret_cast<const uint8_t *>(EsdPtrs[DefEsdId]);
+  ESDRecord::getLength(EsdRecord, Length);
+  LLVM_DEBUG(dbgs() << "Got section size: " << Length << '\n');
+  return static_cast<uint64_t>(Length);
+}
+
+// Unravel TXT records and expand fill characters to produce
+// a contiguous sequence of bytes
+Expected<ArrayRef<uint8_t>>
+GOFFObjectFile::getSectionContents(DataRefImpl Sec) const {
+  if (SectionData.count(Sec.d.a)) {
+    StringRef Res = StringRef(SectionData[Sec.d.a]);
+    return arrayRefFromStringRef(Res);
+  }
+
+  uint64_t SectionSize = getSectionSize(Sec);
+  uint32_t DefEsdId = getSectionDefEsdId(Sec);
+
+  const uint8_t *EdEsdRecord = getSectionEdEsdRecord(Sec);
+  bool FillBytePresent;
+  ESDRecord::getFillBytePresent(EdEsdRecord, FillBytePresent);
+  uint8_t FillByte = '\0';
+  if (FillBytePresent)
+    ESDRecord::getFillByteValue(EdEsdRecord, FillByte);
+
+  // Initialize section with fill byte
+
+  std::string &Data = SectionData[Sec.d.a];
+  Data.reserve(SectionSize);
+  Data.insert(0, SectionSize, FillByte);
+
+  // Replace section with context from text records
+
+  std::vector<uintptr_t> TxtRecords;
+  for (uintptr_t TxtRecordInt : TextPtrs) {
+    const uint8_t *TxtRecordPtr =
+        reinterpret_cast<const uint8_t *>(TxtRecordInt);
+    uint32_t TxtEsdId;
+    TXTRecord::getElementEsdId(TxtRecordPtr, TxtEsdId);
+    LLVM_DEBUG(dbgs() << "Got txt EsdId: " << TxtEsdId << '\n');
+
+    if (TxtEsdId == DefEsdId)
+      TxtRecords.push_back(TxtRecordInt);
+  }
+  LLVM_DEBUG(dbgs() << "Found " << TxtRecords.size() << " matching records\n");
+
+  for (uintptr_t TxtRecordInt : TxtRecords) {
+    const uint8_t *TxtRecordPtr =
+        reinterpret_cast<const uint8_t *>(TxtRecordInt);
+    uint32_t TxtDataOffset;
+    TXTRecord::getOffset(TxtRecordPtr, TxtDataOffset);
+    LLVM_DEBUG(dbgs() << "Got record data offset: " << TxtDataOffset << '\n');
+    uint32_t CurrentOffset = TxtDataOffset;
+
+    uint16_t TxtDataSize;
+    TXTRecord::getDataLength(TxtRecordPtr, TxtDataSize);
+    LLVM_DEBUG(dbgs() << "Got record data size: " << TxtDataSize << '\n');
+
+    // Need char* from here on
+    char *ChrPtr = reinterpret_cast<char *>(TxtRecordInt);
+    if (TxtDataSize < TXTRecord::TXTMaxDataLength) {
+      Data.replace(CurrentOffset, TxtDataSize, ChrPtr + 24, TxtDataSize);
+      CurrentOffset += TxtDataSize;
+    } else {
+      Data.replace(CurrentOffset, TXTRecord::TXTMaxDataLength, ChrPtr + 24,
+                   TXTRecord::TXTMaxDataLength);
+      CurrentOffset += TXTRecord::TXTMaxDataLength;
+      ChrPtr += GOFF::RecordLength; // Advance record
+
+      // Consume continuation records
+      uint16_t ConsumedCounter = TXTRecord::TXTMaxDataLength; // Start at offset
+      while (ConsumedCounter < TxtDataSize) {
+        uint16_t Diff = TxtDataSize - ConsumedCounter;
+        if (Diff < ContinuationRecord::ContinuationMaxDataLength) {
+          Data.replace(CurrentOffset, Diff, ChrPtr + 3, Diff);
+          CurrentOffset += Diff;
+          ConsumedCounter += Diff;
+          assert(ConsumedCounter == TxtDataSize &&
+                 "Should have consumed all bytes from logical record");
+        } else {
+          Data.replace(
+              CurrentOffset, ContinuationRecord::ContinuationMaxDataLength,
+              ChrPtr + 3, ContinuationRecord::ContinuationMaxDataLength);
+          CurrentOffset += ContinuationRecord::ContinuationMaxDataLength;
+          ConsumedCounter += ContinuationRecord::ContinuationMaxDataLength;
+          ChrPtr += GOFF::RecordLength; // Advance record
+        }
+      }
+    }
+  }
+
+  StringRef Res = StringRef(Data);
+  return arrayRefFromStringRef(Res);
+}
+
+uint64_t GOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
+  const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+  GOFF::ESDAlignment Pow2Alignment;
+  ESDRecord::getAlignment(EsdRecord, Pow2Alignment);
+  uint64_t ByteAlignment = 1 << (uint64_t)Pow2Alignment;
+  return ByteAlignment;
+}
+
+bool GOFFObjectFile::isSectionCompressed(DataRefImpl Sec) const {
+  return false;
+}
+
+bool GOFFObjectFile::isSectionText(DataRefImpl Sec) const {
+  const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+  GOFF::ESDExecutable Executable;
+  ESDRecord::getExecutable(EsdRecord, Executable);
+  bool IsSectionText = (Executable == GOFF::ESD_EXE_CODE);
+  return IsSectionText;
+}
+
+bool GOFFObjectFile::isSectionData(DataRefImpl Sec) const {
+  const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+  GOFF::ESDExecutable Executable;
+  ESDRecord::getExecutable(EsdRecord, Executable);
+  bool IsSectionData = (Executable == GOFF::ESD_EXE_DATA);
+  return IsSectionData;
+}
+
+bool GOFFObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
+
+bool GOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
+
+bool GOFFObjectFile::isSectionNoLoad(DataRefImpl Sec) const {
+  const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+  GOFF::ESDLoadingBehavior LoadingBehavior;
+  ESDRecord::getLoadingBehavior(EsdRecord, LoadingBehavior);
+  bool Result = LoadingBehavior == GOFF::ESD_LB_NoLoad;
+  return Result;
+}
+
+bool GOFFObjectFile::isSectionReadOnlyData(DataRefImpl Sec) const {
+  bool Result;
+  if (isSectionData(Sec)) {
+    const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
+    GOFF::ESDLoadingBehavior LoadingBehavior;
+    ESDRecord::getLoadingBehavior(EsdRecord, LoadingBehavior);
+    Result = LoadingBehavior == GOFF::ESD_LB_Initial;
+  } else {
+    Result = false;
+  }
+  return Result;
+}
+
+bool GOFFObjectFile::isSectionZeroInit(DataRefImpl Sec) const {
+  // GOFF uses fill characters and fill characters are  applied
+  // on getSectionContents() - so we say false to zero init
+  bool Result = false;
+  return Result;
+}
+
+relocation_iterator GOFFObjectFile::section_rel_begin(DataRefImpl Sec) const {
+  DataRefImpl Rel;
+  RelocationIteratorState_t *RIS =
+      (RelocationIteratorState_t *)calloc(1, sizeof(RelocationIteratorState_t));
+  RIS->Sec = Sec;
+  RIS->SectionDefId = getSectionDefEsdId(Sec);
+  Rel.p = reinterpret_cast<uintptr_t>(RIS);
+  moveRelocationNext(Rel);
+  return relocation_iterator(RelocationRef(Rel, this));
+}
+
+relocation_iterator GOFFObjectFile::section_rel_end(DataRefImpl Sec) const {
+  DataRefImpl Rel;
+  return relocation_iterator(RelocationRef(Rel, this));
+}
+
+// RelocationRef
+void GOFFObjectFile::getRelocationData() {
+  if (RelocationData.size())
+    return;
+
+  // Calculate total length of relocation items from all records
+  uint32_t RelocationDataSize = 0;
+  uint16_t RldLengthField;
+  for (uint32_t I = 0; I < RldPtrs.size(); I++) {
+    const uint8_t *RldRecord = reinterpret_cast<const uint8_t *>(RldPtrs[I]);
+    RLDRecord::getLength(RldRecord, RldLengthField);
+    RelocationDataSize += RldLengthField;
+  }
+
+  RelocationData.reserve(RelocationDataSize);
+
+  // Populate RelocationData with relocation items from all records
+  for (uint32_t I = 0; I < RldPtrs.size(); I++) {
+    const uint8_t *RldRecord = reinterpret_cast<const uint8_t *>(RldPtrs[I]);
+    RLDRecord::getLength(RldRecord, RldLengthField);
+    uint16_t Remainder = RldLengthField;
+
+    uint32_t AppendLength = Remainder < (GOFF::RecordLength - 6)
+                                ? Remainder
+                                : (GOFF::RecordLength - 6);
+    const char *ChrPtr = reinterpret_cast<const char *>(RldRecord);
+    RelocationData.append(ChrPtr + 6, AppendLength); // copy from initial record
+    Remainder -= AppendLength;
+    ChrPtr += GOFF::RecordLength;
+    while (Remainder > 0) {
+      AppendLength = Remainder < (GOFF::RecordLength - 3)
+                         ? Remainder
+                         : (GOFF::RecordLength - 3);
+      RelocationData.append(ChrPtr + 3, AppendLength); // copy from continuation
+      Remainder -= AppendLength;
+      ChrPtr += GOFF::RecordLength;
+    }
+  }
+}
+
+void GOFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
+  RelocationIteratorState_t *RIS = (RelocationIteratorState_t *)Rel.p;
+  if (!RIS)
+    return;
+
+#define F_SAME_R_ID 0x80
+#define F_SAME_P_ID 0x40
+#define F_SAME_OFFSET 0x20
+#define F_EXT_ATTR_PRESENT 0x04
+#define F_8_BYTE_OFFSET 0x02
+
+  // In GOFF, relocations are not ordered by section so
+  // we search to find the next relevent relocation
+  // for the section. Also, we keep state information as a relocations
+  // can be compact and inherit values from a prior relocation.
+  // In addition, a "relocation type" encodes a lot of information
+  // such as type, size and bit offsets, actions, and some symbol
+  // flags (such as weak and indirect).  This makes the "relocation
+  // type" type detailed enough to support MCJIT resolution
+  // and relocation phases. The getRLDx() routines below
+  // are to be used to extract particular information.
+  const uint8_t *Data =
+      reinterpret_cast<const uint8_t *>(RelocationData.data());
+  while (RIS->RelocationDataOffset < RelocationData.size()) {
+    RIS->RelocationDataOffset += RIS->CurrentRldSize;
+    const uint8_t *Rld = Data + RIS->RelocationDataOffset;
+    uint8_t Flags0 = Rld[0];
+
+    int32_t CurrOffset = 8;
+    if (!(Flags0 & F_SAME_R_ID)) {
+      RIS->OReferenceId = support::endian::read32be(&Rld[CurrOffset]);
+      CurrOffset += 4;
+    }
+    if (!(Flags0 & F_SAME_P_ID)) {
+      RIS->OPositionId = support::endian::read32be(&Rld[CurrOffset]);
+      CurrOffset += 4;
+    }
+    if (!(Flags0 & F_SAME_OFFSET)) {
+      if (Flags0 & F_8_BYTE_OFFSET) {
+        RIS->OOffset = support::endian::read64be(&Rld[CurrOffset]);
+        CurrOffset += 8;
+      } else {
+        RIS->OOffset = support::endian::read32be(&Rld[CurrOffset]);
+        CurrOffset += 4;
+      }
+    }
+    if (Flags0 & F_EXT_ATTR_PRESENT)
+      CurrOffset += 8;
+
+    RIS->CurrentRldSize = CurrOffset;
+
+    if (RIS->OPositionId == RIS->SectionDefId) {
+      RIS->PosOffset = RIS->OOffset;
+      RIS->RefSymb.d.a = RIS->OReferenceId;
+      const uint8_t *Data =
+          reinterpret_cast<const uint8_t *>(RelocationData.data());
+      const uint8_t *Rld = Data + RIS->RelocationDataOffset;
+      //                     === length & bit offset ===   = type action/fetch =
+      RIS->RelocationType =
+          (Rld[4] << 24) + (Rld[5] << 16) + (Rld[1] << 8) + Rld[2];
+      // Note: we encode indirect, weak, and code address flags in the high
+      // word of RelocationType.
+#define RLD_INDIRECT_FLAG 0x400000000
+#define RLD_CODE_ADDR_FLAG 0x200000000
+#define RLD_WEAK_FLAG 0x100000000
+      if (isSymbolIndirect(RIS->RefSymb)) {
+        RIS->RelocationType |= RLD_INDIRECT_FLAG;
+      } else if (getRLDReferenceType(RIS->RelocationType) !=
+                 GOFF::RLD_RT_RTypeConstant) {
+        // A reference to a function could refer to the functions descriptor
+        // (via indirect indicator) or to the ADA of the function
+        // (via reference type of RLD_RT_RTypeConstant) or to the executable
+        // code address of the function.  Add an indicator this relocation
+        // refers to the code address of the function. These 3 flags make
+        // relocation processing easier
+        auto SymTypeOrErr = getSymbolType(RIS->RefSymb);
+        if (SymTypeOrErr) {
+          SymbolRef::Type SymType = *SymTypeOrErr;
+          if (SymType == SymbolRef::ST_Function)
+            RIS->RelocationType |= RLD_CODE_ADDR_FLAG;
+        }
+      }
+      uint32_t Flags = cantFail(getSymbolFlags(RIS->RefSymb));
+      if (Flags & SymbolRef::SF_Weak)
+        RIS->RelocationType |= RLD_WEAK_FLAG;
+      return;
+    }
+  }
+
+  free((void *)Rel.p);
+  Rel.p = 0;
+}
+
+uint64_t GOFFObjectFile::getRelocationOffset(DataRefImpl Rel) const {
+  RelocationIteratorState_t *RIS = (RelocationIteratorState_t *)Rel.p;
+  if (RIS) {
+    return RIS->PosOffset;
+  } else {
+    llvm_unreachable("invalid call to getRelocationOffset");
+    return 0;
+  }
+}
+
+symbol_iterator GOFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
+  RelocationIteratorState_t *RIS = (RelocationIteratorState_t *)Rel.p;
+  if (!RIS)
+    llvm_unreachable("invalid call to getRelocationSymbol");
+  return basic_symbol_iterator(SymbolRef(RIS->RefSymb, this));
+}
+
+uint64_t GOFFObjectFile::getRelocationType(DataRefImpl Rel) const {
+  RelocationIteratorState_t *RIS = (RelocationIteratorState_t *)Rel.p;
+  uint64_t RelocationType = 0;
+  if (RIS)
+    RelocationType = RIS->RelocationType;
+  else
+    llvm_unreachable("invalid call to getRelocationType");
+
+  return RelocationType;
+}
+
+void GOFFObjectFile::getRelocationTypeName(
+    DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
+  RelocationIteratorState_t *RIS = (RelocationIteratorState_t *)Rel.p;
+  if (RIS) {
+    uint64_t RelocationType = getRelocationType(Rel);
+    char Buff[16];
+    sprintf(Buff, "R-%1x:%4.4x:%4.4x",
+            (uint16_t)((RelocationType >> 32) & 0x0003),
+            (uint16_t)((RelocationType >> 16) & 0xFFFF),
+            (uint16_t)(RelocationType & 0xFFFF));
+    Result.append(Buff, Buff + strlen(Buff));
+  } else {
+    llvm_unreachable("invalid call to getRelocationTypeName");
+  }
+}
+
+// Utility routines which extract details about the relocation from
+// the relocation type.
+GOFF::RLDFetchStore GOFFObjectFile::getRLDFetchStore(uint64_t RelocationType) {
+  GOFF::RLDFetchStore RFS = (GOFF::RLDFetchStore)(RelocationType & 0x00000001);
+  return RFS;
+}
+GOFF::RLDAction GOFFObjectFile::getRLDAction(uint64_t RelocationType) {
+  GOFF::RLDAction RA = (GOFF::RLDAction)((RelocationType & 0x000000FE) >> 1);
+  return RA;
+}
+GOFF::RLDReferenceType
+GOFFObjectFile::getRLDReferenceType(uint64_t RelocationType) {
+  GOFF::RLDReferenceType RRT =
+      (GOFF::RLDReferenceType)((RelocationType & 0x0000F000) >> 12);
+  return RRT;
+}
+uint8_t GOFFObjectFile::getRLDBitOffset(uint64_t RelocationType) {
+  uint16_t RBO = ((RelocationType & 0x00070000) >> 16);
+  return RBO;
+}
+uint16_t GOFFObjectFile::getRLDBitLength(uint64_t RelocationType) {
+  uint16_t RBL = ((RelocationType & 0xFFE00000) >> 21);
+  return RBL;
+}
+bool GOFFObjectFile::getRLDIsCodeAddressReference(uint64_t RelocationType) {
+  bool IsCodeAddrReference = (RelocationType & RLD_CODE_ADDR_FLAG) != 0;
+  return IsCodeAddrReference;
+}
+bool GOFFObjectFile::getRLDSymbolIsIndirect(uint64_t RelocationType) {
+  bool IsIndirect = (RelocationType & RLD_INDIRECT_FLAG) != 0;
+  return IsIndirect;
+}
+bool GOFFObjectFile::getRLDIsWeak(uint64_t RelocationType) {
+  bool IsWeak = (RelocationType & RLD_WEAK_FLAG) != 0;
+  return IsWeak;
+}
+
+// The following is used to help construct a relocation
+uint32_t GOFFObjectFile::getNormalRelocationType(uint8_t PointerSizeInBytes) {
+  //                   === length & bit offset ===    = types/action/fetch =
+  uint8_t P = PointerSizeInBytes;
+  uint32_t RelocType = (P << 24) + (0 << 16) + (GOFF::RLD_RT_RAddress << 8) + 0;
+  return RelocType;
+}
+
+section_iterator GOFFObjectFile::section_begin() const {
+  DataRefImpl Sec;
+  moveSectionNext(Sec);
+  return section_iterator(SectionRef(Sec, this));
+}
+
+section_iterator GOFFObjectFile::section_end() const {
+  DataRefImpl Sec;
+  return section_iterator(SectionRef(Sec, this));
+}
+
+void GOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
+  for (uint32_t I = Symb.d.a + 1; I < EsdPtrs.size(); ++I) {
+    if (EsdPtrs[I]) {
+      const uint8_t *EsdRecord = reinterpret_cast<const uint8_t *>(EsdPtrs[I]);
+      GOFF::ESDSymbolType SymbolType;
+      ESDRecord::getSymbolType(EsdRecord, SymbolType);
+      // Skip EDs - i.e. section symbols
+      bool IgnoreSpecialGOFFSymbols = true;
+      bool SkipSymbol = ((SymbolType == GOFF::ESD_ST_ElementDefinition) ||
+                         (SymbolType == GOFF::ESD_ST_SectionDefinition)) &&
+                        IgnoreSpecialGOFFSymbols;
+      if (!SkipSymbol) {
+        Symb.d.a = I;
+        return;
+      }
+    }
+  }
+  Symb.d.a = 0; // symbol_end
+}
+
+basic_symbol_iterator GOFFObjectFile::symbol_begin() const {
+  DataRefImpl Symb;
+  moveSymbolNext(Symb);
+  return basic_symbol_iterator(SymbolRef(Symb, this));
+}
+
+basic_symbol_iterator GOFFObjectFile::symbol_end() const {
+  DataRefImpl Symb;
+  return basic_symbol_iterator(SymbolRef(Symb, this));
+}

llvm/lib/Object/ObjectFile.cpp

 //===- ObjectFile.cpp - File format independent object file ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
Triple ObjectFile::makeTriple() const {
   } else if (isCOFF()) {
     const auto COFFObj = cast<COFFObjectFile>(this);
     if (COFFObj->getArch() == Triple::thumb)
       TheTriple.setTriple("thumbv7-windows");
   } else if (isXCOFF()) {
     // XCOFF implies AIX.
     TheTriple.setOS(Triple::AIX);
     TheTriple.setObjectFormat(Triple::XCOFF);
+  } else if (isGOFF()) {
+    TheTriple.setOS(Triple::ZOS);
+    TheTriple.setObjectFormat(Triple::GOFF);
   }
 
   return TheTriple;
 }
 
 Expected<std::unique_ptr<ObjectFile>>
 ObjectFile::createObjectFile(MemoryBufferRef Object, file_magic Type) {
   StringRef Data = Object.getBuffer();
ObjectFile::createObjectFile(MemoryBufferRef Object, file_magic Type) {
   case file_magic::macho_preload_executable:
   case file_magic::macho_dynamically_linked_shared_lib:
   case file_magic::macho_dynamic_linker:
   case file_magic::macho_bundle:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::macho_dsym_companion:
   case file_magic::macho_kext_bundle:
     return createMachOObjectFile(Object);
+  case file_magic::goff_object:
+    return createGOFFObjectFile(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, Binary::ID_XCOFF32);
   case file_magic::xcoff_object_64:
     return createXCOFFObjectFile(Object, Binary::ID_XCOFF64);

llvm/lib/Object/SymbolicFile.cpp

 //===- SymbolicFile.cpp - Interface that only provides symbols ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
SymbolicFile::createSymbolicFile(MemoryBufferRef Object, file_magic Type,
   case file_magic::macho_preload_executable:
   case file_magic::macho_dynamically_linked_shared_lib:
   case file_magic::macho_dynamic_linker:
   case file_magic::macho_bundle:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::macho_dsym_companion:
   case file_magic::macho_kext_bundle:
   case file_magic::pecoff_executable:
+  case file_magic::goff_object:
   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:

llvm/test/tools/llvm-readobj/GOFF/goff-basic.test

+# RUN: llvm-readobj --symbols %p/Inputs/goff-basic.o | \
+# RUN: FileCheck --check-prefix=SYMBOLSEXP %s
+
+# RUN: llvm-readobj --relocs --expand-relocs %p/Inputs/goff-basic.o | \
+# RUN: FileCheck --check-prefix=RELOCSEXP %s
+
+# SYMBOLSEXP: File: {{.*}}goff-basic.o
+# SYMBOLSEXP-NEXT: Format: GOFF-SystemZ
+# SYMBOLSEXP-NEXT: Arch: s390x
+# SYMBOLSEXP-NEXT: AddressSize: 64bit
+# SYMBOLSEXP-NEXT: Symbols [
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: test#C
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: test#S
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: .&ppa2
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: a
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: b
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: d
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: CELQSTRT
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: A
+# SYMBOLSEXP-NEXT:     Value: 16
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: B
+# SYMBOLSEXP-NEXT:     Value: 48
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: D
+# SYMBOLSEXP-NEXT:     Value: 80
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: @a
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: @b
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: @d
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT: ]
+
+# RELOCSEXP: File: {{.*}}goff-basic.o
+# RELOCSEXP-NEXT: Format: GOFF-SystemZ
+# RELOCSEXP-NEXT: Arch: s390x
+# RELOCSEXP-NEXT: AddressSize: 64bit
+# RELOCSEXP-NEXT: Relocations [
+# RELOCSEXP-NEXT:  Section (1) C_CODE64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0xB6
+# RELOCSEXP-NEXT:      Type: R-2:0400:0000
+# RELOCSEXP-NEXT:      Symbol: CELQSTRT
+# RELOCSEXP-NEXT:      Flags: Fetch Code Add Length 0x4
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0xB6
+# RELOCSEXP-NEXT:      Type: R-2:0400:0002
+# RELOCSEXP-NEXT:      Symbol: test#C
+# RELOCSEXP-NEXT:      Flags: Fetch Code Subtract Length 0x4
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (2) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x10
+# RELOCSEXP-NEXT:      Type: R-0:0800:0001
+# RELOCSEXP-NEXT:      Symbol: d
+# RELOCSEXP-NEXT:      Flags: Store Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0001
+# RELOCSEXP-NEXT:      Symbol: a
+# RELOCSEXP-NEXT:      Flags: Store Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x8
+# RELOCSEXP-NEXT:      Type: R-0:0800:0001
+# RELOCSEXP-NEXT:      Symbol: b
+# RELOCSEXP-NEXT:      Flags: Store Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (3) C_@@QPPA2 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-2:0800:0000
+# RELOCSEXP-NEXT:      Symbol: test#C
+# RELOCSEXP-NEXT:      Flags: Fetch Code Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-2:0800:0002
+# RELOCSEXP-NEXT:      Symbol: CELQSTRT
+# RELOCSEXP-NEXT:      Flags: Fetch Code Subtract Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (7) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0000
+# RELOCSEXP-NEXT:      Symbol: a
+# RELOCSEXP-NEXT:      Flags: Fetch Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (8) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0000
+# RELOCSEXP-NEXT:      Symbol: b
+# RELOCSEXP-NEXT:      Flags: Fetch Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (9) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0000
+# RELOCSEXP-NEXT:      Symbol: d
+# RELOCSEXP-NEXT:      Flags: Fetch Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:]
+
+# goff-basic.o was compiled with `clang -c goff-basic.c`
+# from the following source:
+# int a = 55;
+# int b;
+# double d;
+# int A() { return a; }
+# int B() { return b; }
+# double D() { return d; }

llvm/tools/llvm-objdump/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Support
   Symbolize
   )
 
 add_llvm_tool(llvm-objdump
   llvm-objdump.cpp
   COFFDump.cpp
   ELFDump.cpp
+  GOFFDump.cpp
   MachODump.cpp
   WasmDump.cpp
   XCOFFDump.cpp
   )
 
 if(HAVE_LIBXAR)
   target_link_libraries(llvm-objdump PRIVATE ${XAR_LIB})
 endif()
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(objdump llvm-objdump)
 endif()

llvm/tools/llvm-objdump/GOFFDump.h

+//===-- GOFFDump.h - GOFF-specific dumper ------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_OBJDUMP_GOFFDUMP_H
+#define LLVM_TOOLS_LLVM_OBJDUMP_GOFFDUMP_H
+
+#include "llvm/Object/GOFFObjectFile.h"
+
+namespace llvm {
+
+class Error;
+
+namespace objdump {
+
+Error getGOFFRelocationValueString(const object::GOFFObjectFile *Obj,
+                                   const object::RelocationRef &Rel,
+                                   llvm::SmallVectorImpl<char> &Result);
+
+} // namespace objdump
+} // namespace llvm
+
+#endif

llvm/tools/llvm-objdump/GOFFDump.cpp

+//===-- GOFFDump.cpp - GOFF-specific dumper -------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements the GOFF-specific dumper for llvm-objdump.
+///
+//===----------------------------------------------------------------------===//
+
+#include "GOFFDump.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+Error objdump::getGOFFRelocationValueString(const GOFFObjectFile *Obj,
+                                            const RelocationRef &Rel,
+                                            SmallVectorImpl<char> &Result) {
+  symbol_iterator SymI = Rel.getSymbol();
+  Expected<StringRef> SymNameOrErr = SymI->getName();
+  if (!SymNameOrErr)
+    return SymNameOrErr.takeError();
+  StringRef SymName = *SymNameOrErr;
+  Result.append(SymName.begin(), SymName.end());
+  return Error::success();
+}

llvm/tools/llvm-objdump/llvm-objdump.cpp

 //===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===//
 //
 // 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 program is a utility that works like binutils "objdump", that is, it
 // dumps out a plethora of information about an object file depending on the
 // flags.
 //
 // The flags and output of this program should be near identical to those of
 // binutils objdump.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-objdump.h"
 #include "COFFDump.h"
 #include "ELFDump.h"
+#include "GOFFDump.h"
 #include "MachODump.h"
 #include "WasmDump.h"
 #include "XCOFFDump.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/CodeGen/FaultMaps.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/GOFF.h"
+#include "llvm/Object/GOFFObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
static Error getRelocationValueString(const RelocationRef &Rel,
   if (auto *ELF = dyn_cast<ELFObjectFileBase>(Obj))
     return getELFRelocationValueString(ELF, Rel, Result);
   if (auto *COFF = dyn_cast<COFFObjectFile>(Obj))
     return getCOFFRelocationValueString(COFF, Rel, Result);
   if (auto *Wasm = dyn_cast<WasmObjectFile>(Obj))
     return getWasmRelocationValueString(Wasm, Rel, Result);
   if (auto *MachO = dyn_cast<MachOObjectFile>(Obj))
     return getMachORelocationValueString(MachO, Rel, Result);
+  if (auto *GOFF = dyn_cast<GOFFObjectFile>(Obj))
+    return getGOFFRelocationValueString(GOFF, Rel, Result);
   if (auto *XCOFF = dyn_cast<XCOFFObjectFile>(Obj))
     return getXCOFFRelocationValueString(XCOFF, Rel, Result);
   llvm_unreachable("unknown object file format");
 }
 
 /// Indicates whether this relocation should hidden when listing
 /// relocations, usually because it is the trailing part of a multipart
 /// relocation that will be printed as part of the leading relocation.

llvm/tools/llvm-readobj/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   DebugInfoPDB
   )
 
 add_llvm_tool(llvm-readobj
   ARMWinEHPrinter.cpp
   COFFDumper.cpp
   COFFImportDumper.cpp
   ELFDumper.cpp
+  GOFFDumper.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/tools/llvm-readobj/GOFFDumper.cpp

+#include "ObjDumper.h"
+#include "llvm-readobj.h"
+#include "llvm/Object/GOFFObjectFile.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+namespace {
+
+class GOFFDumper : public ObjDumper {
+public:
+  GOFFDumper(const GOFFObjectFile *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 {}
+
+  const object::GOFFObjectFile *getGOFFObject() const { return Obj; };
+
+private:
+  void printSymbol(const SymbolRef &Sym);
+  void printRelocation(const SectionRef &Section, const RelocationRef &Reloc);
+
+  const GOFFObjectFile *Obj;
+};
+
+} // End anonymous namespace
+
+namespace llvm {
+std::unique_ptr<ObjDumper> createGOFFDumper(const object::GOFFObjectFile &Obj,
+                                            ScopedPrinter &Writer) {
+  return std::make_unique<GOFFDumper>(&Obj, Writer);
+}
+
+} // namespace llvm
+
+void GOFFDumper::printSymbol(const SymbolRef &Symbol) {
+  DictScope D(W, "Symbol");
+
+  StringRef SymbolName;
+  if (!Obj->getSymbolName(Symbol, SymbolName))
+    W.printString("Name", SymbolName);
+  Expected<uint64_t> SymVal = Symbol.getValue();
+  if (!SymVal)
+    reportError(SymVal.takeError(), Obj->getFileName());
+  W.printNumber("Value", *SymVal);
+  W.printNumber("Alignment", Symbol.getAlignment());
+}
+
+void GOFFDumper::printRelocation(const SectionRef &Section,
+                                 const RelocationRef &Reloc) {
+  uint64_t Offset = Reloc.getOffset();
+  uint64_t RelocType = Reloc.getType();
+  SmallString<32> RelocName;
+  StringRef SymbolName;
+  Reloc.getTypeName(RelocName);
+  symbol_iterator Symbol = Reloc.getSymbol();
+  if (Symbol != Obj->symbol_end()) {
+    Expected<StringRef> SymbolNameOrErr = Symbol->getName();
+    if (!SymbolNameOrErr)
+      reportError(SymbolNameOrErr.takeError(), Obj->getFileName());
+
+    SymbolName = *SymbolNameOrErr;
+  }
+
+  std::vector<std::string> Flags;
+  Flags.push_back(Obj->getRLDFetchStore(RelocType) == GOFF::RLD_FS_Fetch
+                      ? "Fetch"
+                      : "Store");
+  if (Obj->getRLDIsCodeAddressReference(RelocType))
+    Flags.push_back("Code");
+  if (Obj->getRLDSymbolIsIndirect(RelocType))
+    Flags.push_back("Indirect");
+  if (Obj->getRLDIsWeak(RelocType))
+    Flags.push_back("Weak");
+  switch (Obj->getRLDAction(RelocType)) {
+#define CASE(X)                                                                \
+  case GOFF::RLD_ACT_##X:                                                      \
+    Flags.push_back(#X);                                                       \
+    break
+    CASE(Multiply);
+    CASE(Div4Quotient);
+    CASE(Div4Remainder);
+    CASE(And);
+    CASE(Or);
+    CASE(Xor);
+    CASE(Move);
+#undef CASE
+  }
+  uint8_t BitOffset = Obj->getRLDBitOffset(RelocType);
+  uint16_t BitLength = Obj->getRLDBitLength(RelocType);
+  if ((BitLength & 0x07) || BitOffset)
+    Flags.push_back(llvm::Twine("Bit Length+Offset 0x")
+                        .concat(llvm::utohexstr(BitLength))
+                        .concat(" +")
+                        .concat(llvm::utohexstr(BitOffset))
+                        .str());
+  else
+    Flags.push_back(
+        llvm::Twine("Length 0x").concat(llvm::utohexstr(BitLength >> 3)).str());
+
+  if (opts::ExpandRelocs) {
+    DictScope Group(W, "Relocation");
+    W.printHex("Offset", Offset);
+    W.printString("Type", RelocName);
+    W.printString("Symbol", SymbolName.empty() ? "-" : SymbolName);
+    W.printString("Flags", llvm::join(Flags, " "));
+  } else {
+    raw_ostream &OS = W.startLine();
+    OS << W.hex(Offset) << " " << RelocName << " "
+       << (SymbolName.empty() ? "-" : SymbolName) << " "
+       << llvm::join(Flags, " ") << "\n";
+  }
+}
+
+void GOFFDumper::printSectionHeaders() {
+  ListScope SectionsD(W, "Sections");
+  for (const SectionRef &Sec : Obj->sections()) {
+    StringRef Name = unwrapOrError(Obj->getFileName(), Sec.getName());
+
+    DictScope D(W, "Section");
+    W.printNumber("Index", Sec.getIndex());
+    W.printString("Name", Name);
+    W.printHex("Address", Sec.getAddress());
+    W.printHex("Size", Sec.getSize());
+    W.printNumber("Alignment", Sec.getAlignment());
+
+    if (opts::SectionRelocations) {
+      ListScope D(W, "Relocations");
+      for (const RelocationRef &Reloc : Sec.relocations())
+        printRelocation(Sec, Reloc);
+    }
+
+    if (opts::SectionSymbols) {
+      ListScope D(W, "Symbols");
+      for (const SymbolRef &Symbol : Obj->symbols()) {
+        if (!Sec.containsSymbol(Symbol))
+          continue;
+
+        printSymbol(Symbol);
+      }
+    }
+
+    if (opts::SectionData) {
+      StringRef Data = unwrapOrError(Obj->getFileName(), Sec.getContents());
+      W.printBinaryBlock("SectionData", Data);
+    }
+  }
+}
+
+void GOFFDumper::printSymbols() {
+  ListScope Group(W, "Symbols");
+
+  for (const SymbolRef &Symbol : Obj->symbols())
+    printSymbol(Symbol);
+}
+
+void GOFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); }
+
+void GOFFDumper::printRelocations() {
+  ListScope D(W, "Relocations");
+
+  for (const SectionRef &Section : Obj->sections()) {
+    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+
+    bool PrintedGroup = false;
+    for (const RelocationRef &Reloc : Section.relocations()) {
+      if (!PrintedGroup) {
+        W.startLine() << "Section (" << Section.getIndex() << ") " << Name
+                      << " {\n";
+        W.indent();
+        PrintedGroup = true;
+      }
+
+      printRelocation(Section, Reloc);
+    }
+
+    if (PrintedGroup) {
+      W.unindent();
+      W.startLine() << "}\n";
+    }
+  }
+}

llvm/tools/llvm-readobj/ObjDumper.h

 //===-- ObjDumper.h ---------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 #define LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 
 #include <memory>
 #include <system_error>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 namespace object {
 class COFFImportFile;
 class ObjectFile;
+class GOFFObjectFile;
 class XCOFFObjectFile;
 class ELFObjectFileBase;
 }
 namespace codeview {
 class GlobalTypeTableBuilder;
 class MergingTypeTableBuilder;
 } // namespace codeview
 
std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
                                             ScopedPrinter &Writer);
 
 std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
                                            ScopedPrinter &Writer);
 
 std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
                                              ScopedPrinter &Writer);
 
+std::unique_ptr<ObjDumper> createGOFFDumper(const object::GOFFObjectFile &Obj,
+                                            ScopedPrinter &Writer);
+
 std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
                                             ScopedPrinter &Writer);
 
 std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
                                              ScopedPrinter &Writer);
 
 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/tools/llvm-readobj/llvm-readobj.cpp

 //===- llvm-readobj.cpp - Dump contents of an Object File -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 #include "llvm-readobj.h"
 #include "ObjDumper.h"
 #include "WindowsResourceDumper.h"
 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/GOFFObjectFile.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataTypes.h"
if (const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(&Obj))
     return createCOFFDumper(*COFFObj, Writer);
 
   if (const ELFObjectFileBase *ELFObj = dyn_cast<ELFObjectFileBase>(&Obj))
     return createELFDumper(*ELFObj, Writer);
 
   if (const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(&Obj))
     return createMachODumper(*MachOObj, Writer);
 
+  if (const GOFFObjectFile *GOFFObj = dyn_cast<GOFFObjectFile>(&Obj))
+    return createGOFFDumper(*GOFFObj, Writer);
+
   if (const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(&Obj))
     return createWasmDumper(*WasmObj, Writer);
 
   if (const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(&Obj))
     return createXCOFFDumper(*XObj, Writer);
 
   return createStringError(errc::invalid_argument,
                            "unsupported object file format");