[SystemZ/z/OS] Implement GOFF writer for empty files

[Kai]

Summary

Adds the infrastructure to write GOFF object files.
Also adds a GOFF writer which writes only HDR/END records.

[uweigand]

The SystemZ back-end changes LGTM.

[kpn]

llvm/lib/MC/GOFFObjectWriter.cpp

274

I have found it useful to use the Unix 'dd' command to slide up GOFF files when they cause the Binder to abend. This becomes much harder when this record count field is used. I'm not sure what the upside of this field is.

[Kai]

llvm/lib/MC/GOFFObjectWriter.cpp

274

I need to check if the binder is happy without this field.
Both xlc and xlcang set the record count, so setting the field is consistent with these compilers.

[kpn]

llvm/lib/MC/GOFFObjectWriter.cpp

274

We've been putting zero for the record count for nearly 20 years. It's been fine all that time. If it stopped working I'd get a phone call pretty quickly. Last night's builds on V2R4 ran fine, for example.

[Kai]

• Removed writing logical record count in END record
• Fixed formatting

[Kai]

llvm/lib/MC/GOFFObjectWriter.cpp

274

Updated code to just write out the number of logical records for debug purposes.

[kpn]

llvm/lib/MC/GOFFObjectWriter.cpp

274

Thank you!

[Kai]

More comments about the implementation?
E.g. is the name flags_t acceptable?

[Kai]

Fix path of moved include.

[Kai]

Update formatting.

[RKSimon]

Sorry this isn't an area I know much about.

[Kai]

Rebase on latest main branch.

[kpn]

In D111437#3100240, @Kai wrote:

More comments about the implementation?
E.g. is the name flags_t acceptable?

I wouldn't use `flags_t'. Isn't that namespace reserved by the standard?

It would be helpful if you used the 'git clang-format' command to reformat _only_ the parts that you are changing. There seem to be a number of places that aren't GOFF but have changed formatting. See 'clang/tools/clang-format'.

I have no experience in the MC layer so there's not much I can say about those connecting bits.

[Kai]

I wouldn't use `flags_t'. Isn't that namespace reserved by the standard?

My rational is that I mimic a standard type like uint64_t. Well, may be better to change, to avoid fruitless discussions.

It would be helpful if you used the 'git clang-format' command to reformat _only_ the parts that you are changing. There seem to be a number of places that aren't GOFF but have changed formatting. See 'clang/tools/clang-format'.

Thanks! I do not note that, even if it so obvious. I change it.

[Kai]

• Renamed flags_t to Flags
• Minimized formatting changes

[kpn]

LGTM.

Please wait a couple of days in case there are any comments from anyone else.

[Kai]

Please wait a couple of days in case there are any comments from anyone else.

Sure, no problem. Thanks!

[jhenderson]

Basically stylistic-style comments and questions, as I don't know GOFF at all.

llvm/include/llvm/MC/MCGOFFObjectWriter.h

35

llvm/lib/MC/GOFFObjectWriter.cpp

69

75

My gut says we should be following standard LLVM naming scheme with this class name. The raw_ostream class uses the different style because it's intended to mirror the standard std::ostream class, but I don't think that's a justification to extend it to classes that make use of the stream.

93

"begin" is a verb. You want "start" or "beginning".

114

Similar to my above comment, unless the function is an implementation of a virtual function in the basis class, I'd use standard LLVM lowerCameCase for the methods throughout this class.

139

142

I think the general preference within LLVM is to use C++ static_cast and reinterpret_cast as appropriate, rather than the C-style cast.

177

I don't think you need the NDEBUG check here? Isn't that within the assert macro?

217–219

No braces for single line if.

252

clang-format understands this style for labelling arguments.

272

274

It might be worth a comment explaining why this field is always 0. Otherwirse a future contributor may not be aware of the reasoning and change it to be "correct".

llvm/lib/MC/MCGOFFStreamer.cpp

29–30

This seems like a memory leak?

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZELFObjectWriter.cpp

56

Whilst you're moving this file, I'd consider doing a complete clang-format of it too.

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmBackend.cpp

45–46

clang-format the modified code.

llvm/test/MC/GOFF/empty-goff.s

2

I'd find this syntax easier to follow, as it's a more common style among tests I've worked with.

3

Why do you need the --ignore-case option?

[Kai]

llvm/lib/MC/MCGOFFStreamer.cpp

29–30

Spontaneously I cannot say when the object will be released again. The code corresponds to all other Streamer implementations, e.g. MCELFStreamer.

IMHO it would be better to return a std::unique_ptr<MCStreamer>, but this also required global changes in the way how the object retrieved from the TargetRegistry is handled.

llvm/test/MC/GOFF/empty-goff.s

3

The case of hexadecimal digits is not defined by the POSIX standard.
Consequently, Linux uses upper case digits, and the z/OS USS implementation uses lower case letters.

[Kai]

Addressed review comments.

[Kai]

Thanks for the review!

llvm/lib/MC/GOFFObjectWriter.cpp

93

Sorry, my fault. In German, both words can be used as verb or noun.

177

Yes, agree, the #ifndef is not necessary.

[Kai]

Removed unnecessary #ifndef.

[jhenderson]

llvm/lib/MC/GOFFObjectWriter.cpp

83

It might be worth explaining why this is in an ifdef, in this comment.

140

"BE" being an acronym for "big endian" should be capitalized.

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZELFObjectWriter.cpp

56

Not addressed?

llvm/test/MC/GOFF/empty-goff.s

2

Not addressed?

5–9

For true comments, as opposed to lit or FileCheck directives, I like to use double comment markers, i.e. "** Header record:" etc. Also why "*"? "#" is the more common marker I've seen used (although I admit it doesn't apply everywhere).

[Kai]

Rebase on latest master.

llvm/include/llvm/BinaryFormat/GOFF.h

+//===-- llvm/BinaryFormat/GOFF.h - GOFF definitions --------------*- 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 header contains common, non-processor-specific data structures and
+// 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/2.4.0?topic=facilities-generalized-object-file-format-goff
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BINARYFORMAT_GOFF_H
+#define LLVM_BINARYFORMAT_GOFF_H
+
+#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 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;
+
+/// \brief Prefix byte on every record. This indicates GOFF format.
+constexpr uint8_t PTVPrefix = 0x03;
+
+enum RecordType : uint8_t {
+  RT_ESD = 0,
+  RT_TXT = 1,
+  RT_RLD = 2,
+  RT_LEN = 3,
+  RT_END = 4,
+  RT_HDR = 15,
+};
+
+enum ENDEntryPointRequest : uint8_t {
+  END_EPR_None = 0,
+  END_EPR_EsdidOffset = 1,
+  END_EPR_ExternalName = 2,
+  END_EPR_Reserved = 3,
+};
+
+} // end namespace GOFF
+
+} // end namespace llvm
+
+#endif // LLVM_BINARYFORMAT_GOFF_H

llvm/include/llvm/MC/MCGOFFObjectWriter.h

+//===- 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

+//===- 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,
+                        unsigned ByteAlignment) override {}
+  void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override {}
+  void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+                    uint64_t Size = 0, unsigned ByteAlignment = 0,
+                    SMLoc Loc = SMLoc()) override {}
+};
+
+} // end namespace llvm
+
+#endif

llvm/include/llvm/Support/TargetRegistry.h

createAsmStreamer(MCContext &Ctx, std::unique_ptr<formatted_raw_ostream> OS,
                   MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
                   std::unique_ptr<MCAsmBackend> &&TAB, bool ShowInst);
 
 MCStreamer *createELFStreamer(MCContext &Ctx,
                               std::unique_ptr<MCAsmBackend> &&TAB,
                               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,
                                 std::unique_ptr<MCCodeEmitter> &&CE,
                                 bool RelaxAll, bool DWARFMustBeAtTheEnd,
                                 bool LabelSections = false);
 MCStreamer *createWasmStreamer(MCContext &Ctx,
                                std::unique_ptr<MCAsmBackend> &&TAB,
public:
   using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(const MCInstrInfo &II,
                                                  const MCRegisterInfo &MRI,
                                                  MCContext &Ctx);
   using ELFStreamerCtorTy =
       MCStreamer *(*)(const Triple &T, MCContext &Ctx,
                       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,
                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
                       bool DWARFMustBeAtTheEnd);
   using COFFStreamerCtorTy =
       MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
                       std::unique_ptr<MCObjectWriter> &&OW,
private:
   MCInstPrinterCtorTy MCInstPrinterCtorFn;
 
   /// MCCodeEmitterCtorFn - Construction function for this target's
   /// CodeEmitter, if registered.
   MCCodeEmitterCtorTy MCCodeEmitterCtorFn;
 
   // Construction functions for the various object formats, if registered.
   COFFStreamerCtorTy COFFStreamerCtorFn = nullptr;
+  GOFFStreamerCtorTy GOFFStreamerCtorFn = nullptr;
   MachOStreamerCtorTy MachOStreamerCtorFn = nullptr;
   ELFStreamerCtorTy ELFStreamerCtorFn = nullptr;
   WasmStreamerCtorTy WasmStreamerCtorFn = nullptr;
   XCOFFStreamerCtorTy XCOFFStreamerCtorFn = nullptr;
 
   /// Construction function for this target's null TargetStreamer, if
   /// registered (default = nullptr).
   NullTargetStreamerCtorTy NullTargetStreamerCtorFn = nullptr;
case Triple::Wasm:
       if (WasmStreamerCtorFn)
         S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
                                std::move(Emitter), RelaxAll);
       else
         S = createWasmStreamer(Ctx, std::move(TAB), std::move(OW),
                                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),
                                 std::move(Emitter), RelaxAll);
       else
         S = createXCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
                                 std::move(Emitter), RelaxAll);
       break;
struct TargetRegistry {
   static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn) {
     T.MCCodeEmitterCtorFn = Fn;
   }
 
   static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn) {
     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;
   }
 
   static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn) {
     T.ELFStreamerCtorFn = Fn;
   }
 

llvm/lib/MC/CMakeLists.txt

 add_llvm_component_library(LLVMMC
   ConstantPools.cpp
   ELFObjectWriter.cpp
+  GOFFObjectWriter.cpp
   MCAsmBackend.cpp
   MCAsmInfo.cpp
   MCAsmInfoCOFF.cpp
   MCAsmInfoDarwin.cpp
   MCAsmInfoELF.cpp
   MCAsmInfoGOFF.cpp
   MCAsmInfoWasm.cpp
   MCAsmInfoXCOFF.cpp
   MCAsmMacro.cpp
   MCAsmStreamer.cpp
   MCAssembler.cpp
   MCCodeEmitter.cpp
   MCCodeView.cpp
   MCContext.cpp
   MCDwarf.cpp
   MCELFObjectTargetWriter.cpp
   MCELFStreamer.cpp
   MCExpr.cpp
   MCFragment.cpp
+  MCGOFFStreamer.cpp
   MCInst.cpp
   MCInstPrinter.cpp
   MCInstrAnalysis.cpp
   MCInstrDesc.cpp
   MCInstrInfo.cpp
   MCLabel.cpp
   MCLinkerOptimizationHint.cpp
   MCMachOStreamer.cpp

llvm/lib/MC/GOFFObjectWriter.cpp

+//===- lib/MC/GOFFObjectWriter.cpp - GOFF File Writer ---------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements GOFF object file writer information.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/BinaryFormat/GOFF.h"
+#include "llvm/MC/MCAsmLayout.h"
+#include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCGOFFObjectWriter.h"
+#include "llvm/MC/MCValue.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "goff-writer"
+
+namespace {
+
+// The standard System/390 convention is to name the high-order (leftmost) bit
+// in a byte as bit zero. The flags_t type helps to set bits in a byte according
+// to this numeration order.
+class flags_t {
+  uint8_t Val;
+
+  constexpr static uint8_t bits(uint8_t BitIndex, uint8_t Length, uint8_t Value,
+                                uint8_t OldValue) {
+    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!");
+
+    return (OldValue & ~Mask) | Value;
+  }
+
+public:
+  constexpr flags_t() : Val(0) {}
+  constexpr flags_t(uint8_t BitIndex, uint8_t Length, uint8_t Value)
+      : Val(bits(BitIndex, Length, Value, 0)) {}
+
+  void set(uint8_t BitIndex, uint8_t Length, uint8_t Value) {
+    Val = bits(BitIndex, Length, Value, Val);
+  }
+
+  constexpr operator uint8_t() const { return Val; }
+};
+
+// Common flag values on records.
+
+// Flag: This record is continued.
+constexpr uint8_t RecContinued = flags_t(7, 1, 1);
+
+// Flag: This record is a continuation.
+constexpr uint8_t RecContinuation = flags_t(6, 1, 1);
+
+// The goff_ostream is responsible to write the data into the fixed physical
+// records of the format. A user of this class announces the begin of a new
+// logical record and the size of its content. While writing the content, the
+// physical records are created for the data. Possible fill bytes at the end of
+// a physical record are written automatically. In principle, the goff_ostream
+// is agnostic of the endianness of the content. However, it also supports
+// writing data in big endian byte order.
+class goff_ostream : public raw_ostream {
+  /// The underlying raw_pwrite_stream.
+  raw_pwrite_stream &OS;
+
+  /// The remaining size of this logical record, including fill bytes.
+  size_t RemainingSize;
+
+#ifndef NDEBUG
+  /// The number of bytes needed to fill up the last physical record.
+  size_t Gap = 0;
+#endif
+
+  /// The number of logical records emitted to far.
+  uint32_t LogicalRecords;
+
+  /// The type of the current (logical) record.
+  GOFF::RecordType CurrentType;
+
+  /// Signals begin of new record.
+  bool NewLogicalRecord;
+
+  /// Static allocated buffer for the stream, used by the raw_ostream class. The
+  /// buffer is sized to hold the content of a physical record.
+  char Buffer[GOFF::RecordContentLength];
+
+  // Return the number of bytes left to write until next physical record.
+  // Please note that we maintain the total numbers of byte left, not the
+  // written size.
+  size_t bytesToNextPhysicalRecord() {
+    size_t Bytes = RemainingSize % GOFF::RecordContentLength;
+    return Bytes ? Bytes : GOFF::RecordContentLength;
+  }
+
+  /// Write the record prefix of a physical record, using the given record type.
+  static void write_record_prefix(raw_ostream &OS, GOFF::RecordType Type,
+                                  size_t RemainingSize,
+                                  uint8_t Flags = RecContinuation);
+
+  /// Fill the last physical record of a logical record with zero bytes.
+  void fill_record();
+
+  /// See raw_ostream::write_impl.
+  void write_impl(const char *Ptr, size_t Size) override;
+
+  /// Return the current position within the stream, not counting the bytes
+  /// currently in the buffer.
+  uint64_t current_pos() const override { return OS.tell(); }
+
+public:
+  explicit goff_ostream(raw_pwrite_stream &OS)
+      : OS(OS), RemainingSize(0), LogicalRecords(0), NewLogicalRecord(false) {
+    SetBuffer(Buffer, sizeof(Buffer));
+  }
+
+  ~goff_ostream() { finalize(); }
+
+  raw_pwrite_stream &getOS() { return OS; }
+
+  void new_record(GOFF::RecordType Type, size_t Size);
+
+  void finalize() { fill_record(); }
+
+  uint32_t logical_records() { return LogicalRecords; }
+
+  // Support for endian specific data.
+  template <typename value_type> void write_be(value_type Value) {
+    Value = support::endian::byte_swap<value_type>(Value, support::big);
+    write((const char *)&Value, sizeof(value_type));
+  }
+};
+
+void goff_ostream::write_record_prefix(raw_ostream &OS, GOFF::RecordType Type,
+                                       size_t RemainingSize, uint8_t Flags) {
+  uint8_t TypeAndFlags = Flags | (Type << 4);
+  if (RemainingSize > GOFF::RecordLength)
+    TypeAndFlags |= RecContinued;
+  OS << static_cast<unsigned char>(GOFF::PTVPrefix) // Record Type
+     << static_cast<unsigned char>(TypeAndFlags)    // Continuation
+     << static_cast<unsigned char>(0);              // Version
+}
+
+void goff_ostream::new_record(GOFF::RecordType Type, size_t Size) {
+  fill_record();
+  CurrentType = Type;
+  RemainingSize = Size;
+#ifdef NDEBUG
+  size_t Gap;
+#endif
+  Gap = (RemainingSize % GOFF::RecordContentLength);
+  if (Gap) {
+    Gap = GOFF::RecordContentLength - Gap;
+    RemainingSize += Gap;
+  }
+  NewLogicalRecord = true;
+  ++LogicalRecords;
+}
+
+void goff_ostream::fill_record() {
+  assert((GetNumBytesInBuffer() <= RemainingSize) &&
+         "More bytes in buffer than expected");
+  size_t Remains = RemainingSize - GetNumBytesInBuffer();
+  if (Remains) {
+#ifndef NDEBUG
+    assert(Remains == Gap && "Wrong size of fill gap");
+#endif
+    assert((Remains < GOFF::RecordLength) &&
+           "Attempt to fill more than one physical record");
+    raw_ostream::write_zeros(Remains);
+  }
+  flush();
+  assert(RemainingSize == 0 && "Not fully flushed");
+  assert(GetNumBytesInBuffer() == 0 && "Buffer not fully empty");
+}
+
+// This function is called from the raw_ostream implementation if:
+// - The internal buffer is full. Size is excactly the size of the buffer.
+// - Data larger than the internal buffer is written. Size is a multiple of the
+//   buffer size.
+// - flush() has been called. Size is at most the buffer size.
+// The goff_ostream implementation ensures that flush() is called before a new
+// logical record begins. Therefore it is sufficient to check for a new block
+// only once.
+void goff_ostream::write_impl(const char *Ptr, size_t Size) {
+  assert((RemainingSize >= Size) && "Attempt to write too much data");
+  assert(RemainingSize && "Logical record overflow");
+  if (!(RemainingSize % GOFF::RecordContentLength)) {
+    write_record_prefix(OS, CurrentType, RemainingSize,
+                        NewLogicalRecord ? 0 : RecContinuation);
+    NewLogicalRecord = false;
+  }
+  assert(!NewLogicalRecord &&
+         "New logical record not on physical record boundary");
+
+  size_t Idx = 0;
+  while (Size > 0) {
+    size_t BytesToWrite = bytesToNextPhysicalRecord();
+    if (BytesToWrite > Size)
+      BytesToWrite = Size;
+    OS.write(Ptr + Idx, BytesToWrite);
+    Idx += BytesToWrite;
+    Size -= BytesToWrite;
+    RemainingSize -= BytesToWrite;
+    if (Size) {
+      write_record_prefix(OS, CurrentType, RemainingSize);
+    }
+  }
+}
+
+class GOFFObjectWriter : public MCObjectWriter {
+  // The target specific GOFF writer instance.
+  std::unique_ptr<MCGOFFObjectTargetWriter> TargetObjectWriter;
+
+  // The stream used to write the GOFF records.
+  goff_ostream OS;
+public:
+  GOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW,
+                   raw_pwrite_stream &OS)
+      : TargetObjectWriter(std::move(MOTW)), OS(OS) {}
+
+  ~GOFFObjectWriter() override {}
+
+  // Write GOFF records.
+  void writeHeader();
+  void writeEnd();
+
+  // Implementation of the MCObjectWriter interface.
+  void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
+                        const MCFragment *Fragment, const MCFixup &Fixup,
+                        MCValue Target, uint64_t &FixedValue) override {}
+  void executePostLayoutBinding(MCAssembler &Asm,
+                                const MCAsmLayout &Layout) override {}
+  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+};
+} // end anonymous namespace
+
+void GOFFObjectWriter::writeHeader() {
+  OS.new_record(GOFF::RT_HDR, /* Size = */ 57);
+  OS.write_zeros(1);        // Reserved
+  OS.write_be<uint32_t>(0); // Target Hardware Environment
+  OS.write_be<uint32_t>(0); // Target Operating System Environment
+  OS.write_zeros(2);        // Reserved
+  OS.write_be<uint16_t>(0); // CCSID
+  OS.write_zeros(16);       // Character Set name
+  OS.write_zeros(16);       // Language Product Identifier
+  OS.write_be<uint32_t>(1); // Architecture Level
+  OS.write_be<uint16_t>(0); // Module Properties Length
+  OS.write_zeros(6);        // Reserved
+}
+
+void GOFFObjectWriter::writeEnd() {
+  uint8_t Flags = GOFF::END_EPR_None;
+  uint8_t AMODE = 0;
+  uint32_t ESDID = 0;
+
+  // TODO Set Flags/AMODE/ESDID for entry point.
+
+  OS.new_record(GOFF::RT_END, /* Size = */ 13);
+  OS.write_be<uint8_t>(flags_t(6, 2, Flags));  // Indicator flags
+  OS.write_be<uint8_t>(AMODE);                 // AMODE
+  OS.write_zeros(3);                           // Reserved
+  OS.write_be<uint32_t>(OS.logical_records()); // Record Count
+  OS.write_be<uint32_t>(ESDID);                // ESDID (of entry point)
+  OS.finalize();
+}
+
+uint64_t GOFFObjectWriter::writeObject(MCAssembler &Asm,
+                                       const MCAsmLayout &Layout) {
+  uint64_t StartOffset = OS.tell();
+
+  writeHeader();
+  writeEnd();
+
+  return OS.tell() - StartOffset;
+}
+
+std::unique_ptr<MCObjectWriter>
+llvm::createGOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW,
+                             raw_pwrite_stream &OS) {
+  return std::make_unique<GOFFObjectWriter>(std::move(MOTW), OS);
+}

llvm/lib/MC/MCAsmBackend.cpp

 //===- MCAsmBackend.cpp - Target MC Assembly Backend ----------------------===//
 //
 // 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/MC/MCAsmBackend.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCFixupKindInfo.h"
+#include "llvm/MC/MCGOFFObjectWriter.h"
 #include "llvm/MC/MCMachObjectWriter.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCWasmObjectWriter.h"
 #include "llvm/MC/MCWinCOFFObjectWriter.h"
 #include "llvm/MC/MCXCOFFObjectWriter.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
case Triple::MachO:
     return createMachObjectWriter(cast<MCMachObjectTargetWriter>(std::move(TW)),
                                   OS, Endian == support::little);
   case Triple::COFF:
     return createWinCOFFObjectWriter(
         cast<MCWinCOFFObjectTargetWriter>(std::move(TW)), OS);
   case Triple::Wasm:
     return createWasmObjectWriter(cast<MCWasmObjectTargetWriter>(std::move(TW)),
                                   OS);
+  case Triple::GOFF:
+    return createGOFFObjectWriter(cast<MCGOFFObjectTargetWriter>(std::move(TW)),
+                                  OS);
   case Triple::XCOFF:
     return createXCOFFObjectWriter(
         cast<MCXCOFFObjectTargetWriter>(std::move(TW)), OS);
   default:
     llvm_unreachable("unexpected object format");
   }
 }
 

llvm/lib/MC/MCGOFFStreamer.cpp

+//===- lib/MC/MCGOFFStreamer.cpp - GOFF Object Output ---------------------===//
+//
+// 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 assembles .s files and emits GOFF .o object files.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCGOFFStreamer.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/Support/TargetRegistry.h"
+
+using namespace llvm;
+
+MCGOFFStreamer::~MCGOFFStreamer() {}
+
+MCStreamer *llvm::createGOFFStreamer(MCContext &Context,
+                                     std::unique_ptr<MCAsmBackend> &&MAB,
+                                     std::unique_ptr<MCObjectWriter> &&OW,
+                                     std::unique_ptr<MCCodeEmitter> &&CE,
+                                     bool RelaxAll) {
+  MCGOFFStreamer *S =
+      new MCGOFFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
+  if (RelaxAll)
+    S->getAssembler().setRelaxAll(true);
+  return S;
+}

llvm/lib/Target/SystemZ/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMSystemZDesc
+  SystemZELFObjectWriter.cpp
+  SystemZGOFFObjectWriter.cpp
   SystemZInstPrinter.cpp
   SystemZMCAsmBackend.cpp
   SystemZMCAsmInfo.cpp
   SystemZMCCodeEmitter.cpp
-  SystemZMCObjectWriter.cpp
   SystemZMCTargetDesc.cpp
 
   LINK_COMPONENTS
   MC
   Support
   SystemZInfo
 
   ADD_TO_COMPONENT
   SystemZ
   )

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZELFObjectWriter.cpp

-//===-- SystemZMCObjectWriter.cpp - SystemZ ELF writer --------------------===//
+//===-- SystemZELFObjectWriter.cpp - SystemZ ELF writer -------------------===//
 //
 // 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 "MCTargetDesc/SystemZMCFixups.h"
 #include "MCTargetDesc/SystemZMCTargetDesc.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <cstdint>
 
 using namespace llvm;
 
 namespace {
 
-class SystemZObjectWriter : public MCELFObjectTargetWriter {
+class SystemZELFObjectWriter : public MCELFObjectTargetWriter {
 public:
-  SystemZObjectWriter(uint8_t OSABI);
-  ~SystemZObjectWriter() override = default;
+  SystemZELFObjectWriter(uint8_t OSABI);
+  ~SystemZELFObjectWriter() override = default;
 
 protected:
   // Override MCELFObjectTargetWriter.
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsPCRel) const override;
 };
 
 } // end anonymous namespace
 
-SystemZObjectWriter::SystemZObjectWriter(uint8_t OSABI)
+SystemZELFObjectWriter::SystemZELFObjectWriter(uint8_t OSABI)
   : MCELFObjectTargetWriter(/*Is64Bit_=*/true, OSABI, ELF::EM_S390,
                             /*HasRelocationAddend_=*/ true) {}
 
 // Return the relocation type for an absolute value of MCFixupKind Kind.
 static unsigned getAbsoluteReloc(unsigned Kind) {
   switch (Kind) {
   case FK_Data_1: return ELF::R_390_8;
   case FK_Data_2: return ELF::R_390_16;
   case FK_Data_4: return ELF::R_390_32;
   case FK_Data_8: return ELF::R_390_64;
   }
   llvm_unreachable("Unsupported absolute address");
 }
 
 // Return the relocation type for a PC-relative value of MCFixupKind Kind.
 static unsigned getPCRelReloc(unsigned Kind) {
   switch (Kind) {
   case FK_Data_2:                return ELF::R_390_PC16;
   case FK_Data_4:                return ELF::R_390_PC32;
   case FK_Data_8:                return ELF::R_390_PC64;
   case SystemZ::FK_390_PC12DBL:  return ELF::R_390_PC12DBL;
   case SystemZ::FK_390_PC16DBL:  return ELF::R_390_PC16DBL;
   case SystemZ::FK_390_PC24DBL:  return ELF::R_390_PC24DBL;
   case SystemZ::FK_390_PC32DBL:  return ELF::R_390_PC32DBL;
   }
   llvm_unreachable("Unsupported PC-relative address");
 }
 
 // Return the R_390_TLS_LE* relocation type for MCFixupKind Kind.
 static unsigned getTLSLEReloc(unsigned Kind) {
   switch (Kind) {
   case FK_Data_4: return ELF::R_390_TLS_LE32;
   case FK_Data_8: return ELF::R_390_TLS_LE64;
   }
   llvm_unreachable("Unsupported absolute address");
 }
 
 // Return the R_390_TLS_LDO* relocation type for MCFixupKind Kind.
 static unsigned getTLSLDOReloc(unsigned Kind) {
   switch (Kind) {
   case FK_Data_4: return ELF::R_390_TLS_LDO32;
   case FK_Data_8: return ELF::R_390_TLS_LDO64;
   }
   llvm_unreachable("Unsupported absolute address");
 }
 
 // Return the R_390_TLS_LDM* relocation type for MCFixupKind Kind.
 static unsigned getTLSLDMReloc(unsigned Kind) {
   switch (Kind) {
   case FK_Data_4: return ELF::R_390_TLS_LDM32;
   case FK_Data_8: return ELF::R_390_TLS_LDM64;
   case SystemZ::FK_390_TLS_CALL: return ELF::R_390_TLS_LDCALL;
   }
   llvm_unreachable("Unsupported absolute address");
 }
 
 // Return the R_390_TLS_GD* relocation type for MCFixupKind Kind.
 static unsigned getTLSGDReloc(unsigned Kind) {
   switch (Kind) {
   case FK_Data_4: return ELF::R_390_TLS_GD32;
   case FK_Data_8: return ELF::R_390_TLS_GD64;
   case SystemZ::FK_390_TLS_CALL: return ELF::R_390_TLS_GDCALL;
   }
   llvm_unreachable("Unsupported absolute address");
 }
 
 // Return the PLT relocation counterpart of MCFixupKind Kind.
 static unsigned getPLTReloc(unsigned Kind) {
   switch (Kind) {
   case SystemZ::FK_390_PC12DBL: return ELF::R_390_PLT12DBL;
   case SystemZ::FK_390_PC16DBL: return ELF::R_390_PLT16DBL;
   case SystemZ::FK_390_PC24DBL: return ELF::R_390_PLT24DBL;
   case SystemZ::FK_390_PC32DBL: return ELF::R_390_PLT32DBL;
   }
   llvm_unreachable("Unsupported absolute address");
 }
 
-unsigned SystemZObjectWriter::getRelocType(MCContext &Ctx,
+unsigned SystemZELFObjectWriter::getRelocType(MCContext &Ctx,
                                               const MCValue &Target,
                                               const MCFixup &Fixup,
                                               bool IsPCRel) const {
   unsigned Kind = Fixup.getKind();
   if (Kind >= FirstLiteralRelocationKind)
     return Kind - FirstLiteralRelocationKind;
   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
   switch (Modifier) {
   case MCSymbolRefExpr::VK_None:
     if (IsPCRel)
       return getPCRelReloc(Kind);
     return getAbsoluteReloc(Kind);
 
   case MCSymbolRefExpr::VK_NTPOFF:
     assert(!IsPCRel && "NTPOFF shouldn't be PC-relative");
     return getTLSLEReloc(Kind);
 
   case MCSymbolRefExpr::VK_INDNTPOFF:
     if (IsPCRel && Kind == SystemZ::FK_390_PC32DBL)
       return ELF::R_390_TLS_IEENT;
     llvm_unreachable("Only PC-relative INDNTPOFF accesses are supported for now");
 
   case MCSymbolRefExpr::VK_DTPOFF:
     assert(!IsPCRel && "DTPOFF shouldn't be PC-relative");
     return getTLSLDOReloc(Kind);
 
   case MCSymbolRefExpr::VK_TLSLDM:
     assert(!IsPCRel && "TLSLDM shouldn't be PC-relative");
     return getTLSLDMReloc(Kind);
case MCSymbolRefExpr::VK_PLT:
     return getPLTReloc(Kind);
 
   default:
     llvm_unreachable("Modifier not supported");
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
-llvm::createSystemZObjectWriter(uint8_t OSABI) {
-  return std::make_unique<SystemZObjectWriter>(OSABI);
+llvm::createSystemZELFObjectWriter(uint8_t OSABI) {
+  return std::make_unique<SystemZELFObjectWriter>(OSABI);
 }

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZGOFFObjectWriter.cpp

+//===- SystemZGOFFObjectWriter.cpp - SystemZ GOFF writer ------------------===//
+//
+// 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 "MCTargetDesc/SystemZMCTargetDesc.h"
+#include "llvm/MC/MCGOFFObjectWriter.h"
+
+using namespace llvm;
+
+namespace {
+class SystemZGOFFObjectWriter : public MCGOFFObjectTargetWriter {
+public:
+  SystemZGOFFObjectWriter();
+};
+} // end anonymous namespace
+
+SystemZGOFFObjectWriter::SystemZGOFFObjectWriter()
+    : MCGOFFObjectTargetWriter() {}
+
+std::unique_ptr<MCObjectTargetWriter>
+llvm::createSystemZGOFFObjectWriter() {
+  return std::make_unique<SystemZGOFFObjectWriter>();
+}

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmBackend.cpp

case SystemZ::FK_390_TLS_CALL:
     return 0;
   }
 
   llvm_unreachable("Unknown fixup kind!");
 }
 
 namespace {
 class SystemZMCAsmBackend : public MCAsmBackend {
-  uint8_t OSABI;
 public:
-  SystemZMCAsmBackend(uint8_t osABI)
-      : MCAsmBackend(support::big), OSABI(osABI) {}
+  SystemZMCAsmBackend()
+      : MCAsmBackend(support::big) {}
 
   // Override MCAsmBackend
   unsigned getNumFixupKinds() const override {
     return SystemZ::NumTargetFixupKinds;
   }
   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
   const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override;
   bool shouldForceRelocation(const MCAssembler &Asm, const MCFixup &Fixup,
                              const MCValue &Target) override;
   void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                   const MCValue &Target, MutableArrayRef<char> Data,
                   uint64_t Value, bool IsResolved,
                   const MCSubtargetInfo *STI) const override;
   bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
                             const MCRelaxableFragment *Fragment,
                             const MCAsmLayout &Layout) const override {
     return false;
   }
   bool writeNopData(raw_ostream &OS, uint64_t Count,
                     const MCSubtargetInfo *STI) const override;
-  std::unique_ptr<MCObjectTargetWriter>
-  createObjectTargetWriter() const override {
-    return createSystemZObjectWriter(OSABI);
-  }
 };
 } // end anonymous namespace
 
 Optional<MCFixupKind> SystemZMCAsmBackend::getFixupKind(StringRef Name) const {
   unsigned Type = llvm::StringSwitch<unsigned>(Name)
 #define ELF_RELOC(X, Y) .Case(#X, Y)
 #include "llvm/BinaryFormat/ELFRelocs/SystemZ.def"
 #undef ELF_RELOC

 
 bool SystemZMCAsmBackend::writeNopData(raw_ostream &OS, uint64_t Count,
                                        const MCSubtargetInfo *STI) const {
   for (uint64_t I = 0; I != Count; ++I)
     OS << '\x7';
   return true;
 }
 
+namespace {
+class ELFSystemZAsmBackend : public SystemZMCAsmBackend {
+  uint8_t OSABI;
+
+public:
+  ELFSystemZAsmBackend(uint8_t OsABI) : SystemZMCAsmBackend(), OSABI(OsABI){};
+
+  std::unique_ptr<MCObjectTargetWriter>
+  createObjectTargetWriter() const override {
+    return createSystemZELFObjectWriter(OSABI);
+  }
+};
+
+class GOFFSystemZAsmBackend : public SystemZMCAsmBackend {
+public:
+  GOFFSystemZAsmBackend() : SystemZMCAsmBackend(){};
+
+  std::unique_ptr<MCObjectTargetWriter>
+  createObjectTargetWriter() const override {
+    return createSystemZGOFFObjectWriter();
+  }
+};
+} // namespace
+
 MCAsmBackend *llvm::createSystemZMCAsmBackend(const Target &T,
                                               const MCSubtargetInfo &STI,
                                               const MCRegisterInfo &MRI,
                                               const MCTargetOptions &Options) {
+  if (STI.getTargetTriple().isOSzOS()) {
+    return new GOFFSystemZAsmBackend();
+  }
+
   uint8_t OSABI =
       MCELFObjectTargetWriter::getOSABI(STI.getTargetTriple().getOS());
-  return new SystemZMCAsmBackend(OSABI);
+  return new ELFSystemZAsmBackend(OSABI);
 }

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCTargetDesc.h

MCCodeEmitter *createSystemZMCCodeEmitter(const MCInstrInfo &MCII,
                                           const MCRegisterInfo &MRI,
                                           MCContext &Ctx);
 
 MCAsmBackend *createSystemZMCAsmBackend(const Target &T,
                                         const MCSubtargetInfo &STI,
                                         const MCRegisterInfo &MRI,
                                         const MCTargetOptions &Options);
 
-std::unique_ptr<MCObjectTargetWriter> createSystemZObjectWriter(uint8_t OSABI);
+std::unique_ptr<MCObjectTargetWriter>
+createSystemZELFObjectWriter(uint8_t OSABI);
+std::unique_ptr<MCObjectTargetWriter> createSystemZGOFFObjectWriter();
 } // end namespace llvm
 
 // Defines symbolic names for SystemZ registers.
 // This defines a mapping from register name to register number.
 #define GET_REGINFO_ENUM
 #include "SystemZGenRegisterInfo.inc"
 
 // Defines symbolic names for the SystemZ instructions.
 #define GET_INSTRINFO_ENUM
 #include "SystemZGenInstrInfo.inc"
 
 #define GET_SUBTARGETINFO_ENUM
 #include "SystemZGenSubtargetInfo.inc"
 
 #endif

llvm/test/MC/GOFF/empty-goff.s

+* RUN: llvm-mc <%s --triple s390x-ibm-zos --filetype=obj -o - | \
+* RUN:   od -Ax -tx1 -v | FileCheck --ignore-case %s
+
+* Header record:
+*  03 is prefix byte
+*  f. is header type
+*  .0 is version
+* The 1 at offset 51 is the architecture level.
+* CHECK: 000000 03 f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+* CHECK: 000010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+* CHECK: 000020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+* CHECK: 000030 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00
+* CHECK: 000040 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+
+* End record:
+*  03 is prefix byte
+*  4. is header type
+*  .0 is version
+* The 2 at offset 11 is the number of logical records.
+* CHECK: 000050 03 40 00 00 00 00 00 00 00 00 00 02 00 00 00 00
+* CHECK: 000060 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+* CHECK: 000070 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+* CHECK: 000080 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+* CHECK: 000090 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00