[SystemZ/zOS/GOFF] Implement GOFF writer for empty files.

Set ups the infrastructure to create an empty GOFF file.
Also adds a GOFF writer which writes only HDR/END records.

Reviewed By: jhenderson, kpn

Differential Revision: https://reviews.llvm.org/D111437

Author: redstar

llvm/include/llvm/BinaryFormat/GOFF.h

@@ -10,6 +10,8 @@
 // constants for the GOFF file format.
 //
 // GOFF specifics can be found in MVS Program Management: Advanced Facilities.
+// See
+// https://www.ibm.com/docs/en/zos/3.1.0?topic=facilities-generalized-object-file-format-goff
 //
 //===----------------------------------------------------------------------===//
 
@@ -19,13 +21,24 @@
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
+
 namespace GOFF {
 
+/// \brief Length of the parts of a physical GOFF record.
 constexpr uint8_t RecordLength = 80;
 constexpr uint8_t RecordPrefixLength = 3;
 constexpr uint8_t PayloadLength = 77;
+constexpr uint8_t RecordContentLength = RecordLength - RecordPrefixLength;
+
+/// \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 32K-1 bytes.
+constexpr uint16_t MaxDataLength = 32 * 1024 - 1;
 
-// Prefix byte on every record. This indicates GOFF format.
+/// \brief Prefix byte on every record. This indicates GOFF format.
 constexpr uint8_t PTVPrefix = 0x03;
 
 enum RecordType : uint8_t {

llvm/include/llvm/MC/MCGOFFObjectWriter.h

@@ -0,0 +1,42 @@
+//===- MCGOFFObjectWriter.h - GOFF Object Writer ----------------*- 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_MC_MCGOFFOBJECTWRITER_H
+#define LLVM_MC_MCGOFFOBJECTWRITER_H
+
+#include "llvm/MC/MCObjectWriter.h"
+
+namespace llvm {
+class MCObjectWriter;
+class raw_pwrite_stream;
+
+class MCGOFFObjectTargetWriter : public MCObjectTargetWriter {
+protected:
+  MCGOFFObjectTargetWriter() = default;
+
+public:
+  virtual ~MCGOFFObjectTargetWriter() = default;
+
+  Triple::ObjectFormatType getFormat() const override { return Triple::GOFF; }
+
+  static bool classof(const MCObjectTargetWriter *W) {
+    return W->getFormat() == Triple::GOFF;
+  }
+};
+
+/// \brief Construct a new GOFF writer instance.
+///
+/// \param MOTW - The target-specific GOFF writer subclass.
+/// \param OS - The stream to write to.
+/// \returns The constructed object writer.
+std::unique_ptr<MCObjectWriter>
+createGOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW,
+                       raw_pwrite_stream &OS);
+} // namespace llvm
+
+#endif

llvm/include/llvm/MC/MCGOFFStreamer.h

@@ -0,0 +1,40 @@
+//===- MCGOFFStreamer.h - MCStreamer GOFF Object File Interface--*- 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_MC_MCGOFFSTREAMER_H
+#define LLVM_MC_MCGOFFSTREAMER_H
+
+#include "llvm/MC/MCObjectStreamer.h"
+#include "llvm/MC/MCObjectWriter.h"
+
+namespace llvm {
+
+class MCGOFFStreamer : public MCObjectStreamer {
+public:
+  MCGOFFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
+                 std::unique_ptr<MCObjectWriter> OW,
+                 std::unique_ptr<MCCodeEmitter> Emitter)
+      : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
+                         std::move(Emitter)) {}
+
+  ~MCGOFFStreamer() override;
+
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
+    return false;
+  }
+  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+                        Align ByteAlignment) override {}
+  void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override {}
+  void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+                    uint64_t Size = 0, Align ByteAlignment = Align(1),
+                    SMLoc Loc = SMLoc()) override {}
+};
+
+} // end namespace llvm
+
+#endif

llvm/include/llvm/MC/TargetRegistry.h

@@ -94,6 +94,11 @@ MCStreamer *createELFStreamer(MCContext &Ctx,
                               std::unique_ptr<MCObjectWriter> &&OW,
                               std::unique_ptr<MCCodeEmitter> &&CE,
                               bool RelaxAll);
+MCStreamer *createGOFFStreamer(MCContext &Ctx,
+                               std::unique_ptr<MCAsmBackend> &&TAB,
+                               std::unique_ptr<MCObjectWriter> &&OW,
+                               std::unique_ptr<MCCodeEmitter> &&CE,
+                               bool RelaxAll);
 MCStreamer *createMachOStreamer(MCContext &Ctx,
                                 std::unique_ptr<MCAsmBackend> &&TAB,
                                 std::unique_ptr<MCObjectWriter> &&OW,
@@ -195,6 +200,10 @@ class Target {
                       std::unique_ptr<MCAsmBackend> &&TAB,
                       std::unique_ptr<MCObjectWriter> &&OW,
                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
+  using GOFFStreamerCtorTy =
+      MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
+                      std::unique_ptr<MCObjectWriter> &&OW,
+                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
   using MachOStreamerCtorTy =
       MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
                       std::unique_ptr<MCObjectWriter> &&OW,
@@ -327,6 +336,7 @@ class Target {
 
   // Construction functions for the various object formats, if registered.
   COFFStreamerCtorTy COFFStreamerCtorFn = nullptr;
+  GOFFStreamerCtorTy GOFFStreamerCtorFn = nullptr;
   MachOStreamerCtorTy MachOStreamerCtorFn = nullptr;
   ELFStreamerCtorTy ELFStreamerCtorFn = nullptr;
   WasmStreamerCtorTy WasmStreamerCtorFn = nullptr;
@@ -597,7 +607,13 @@ class Target {
                                std::move(Emitter), RelaxAll);
       break;
     case Triple::GOFF:
-      report_fatal_error("GOFF MCObjectStreamer not implemented yet");
+      if (GOFFStreamerCtorFn)
+        S = GOFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
+                               std::move(Emitter), RelaxAll);
+      else
+        S = createGOFFStreamer(Ctx, std::move(TAB), std::move(OW),
+                               std::move(Emitter), RelaxAll);
+      break;
     case Triple::XCOFF:
       if (XCOFFStreamerCtorFn)
         S = XCOFFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
@@ -1004,6 +1020,10 @@ struct TargetRegistry {
     T.COFFStreamerCtorFn = Fn;
   }
 
+  static void RegisterGOFFStreamer(Target &T, Target::GOFFStreamerCtorTy Fn) {
+    T.GOFFStreamerCtorFn = Fn;
+  }
+
   static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn) {
     T.MachOStreamerCtorFn = Fn;
   }

llvm/lib/MC/CMakeLists.txt

@@ -2,6 +2,7 @@ add_llvm_component_library(LLVMMC
   ConstantPools.cpp
   DXContainerPSVInfo.cpp
   ELFObjectWriter.cpp
+  GOFFObjectWriter.cpp
   MCAsmBackend.cpp
   MCAsmInfo.cpp
   MCAsmInfoCOFF.cpp
@@ -23,6 +24,7 @@ add_llvm_component_library(LLVMMC
   MCELFStreamer.cpp
   MCExpr.cpp
   MCFragment.cpp
+  MCGOFFStreamer.cpp
   MCInst.cpp
   MCInstPrinter.cpp
   MCInstrAnalysis.cpp