[SystemZ][z/OS] Implement executePostLayoutBinding for GOFFWriter

[Everybody0523]

Summary

Implement executePostLayoutBinding function for GOFF Writer. This allows for the generation of ESD Records as well and TXT Records required by functions and global variables (both external and internal).

[DiggerLin]

llvm/include/llvm/BinaryFormat/GOFF.h

81

I got some information from https://www.ibm.com/docs/en/zos/2.1.0?topic=formats-external-symbol-definition-record

X'00'
SD, section definition.

X'01'
ED, element definition.

X'03' PR, part reference

X'04' ER and WX, external reference.

it look your enum member name and value do not same doc ?

do I use the wrong doc ?

llvm/include/llvm/MC/MCAssembler.h

491

can we use const reference here for Name parameter ?

and I can not where the function be used ?

[DiggerLin]

llvm/include/llvm/MC/MCAssembler.h

489

I think we can return a reference here to avoid copy std::pair<std::string, std::string>

llvm/lib/MC/GOFFObjectWriter.cpp

225

the name MC is easy to mess with MC layer, what about MCSym ?

292

what about to change MC to MCSec or other ?

300

we do not need the constructor,

we can change to

const GOFFSymbol *Pptr=nullptr;
const GOFFSymbol *Rptr=nulllptr;
const GOFFSymbol  *SD =nullptr;
const MCSectionGOFF *MC =nullptr;
IsStructured =false;

345

change to const MCAssembler &Asm

373

change to const MCAssembler &Asm , there are still have some in the following code, please change them.

385

what about move data member together?

move above 4 data member to after

size_t SectionWrittenLength = 0; // Logical number of bytes written

423

if the Source must be not nullptr, please add assert here.

441

return createGOFFSymbol(Name, GOFF::ESD_ST_PartReference, ParentEsdId);

[Everybody0523]

llvm/lib/MC/GOFFObjectWriter.cpp

423

So Source doesn't necessarily _need_ to be non-null per say. In the use in this patch, we use it to create the ER Symbols for global objects declared (but not defined) in the module, which correspond to actual instances of MCSymbolGOFFs.

This function can also be used to create ER ESD entries that do not correspond to such things, which we will do in a future patch, such as for CEEMAIN.

[DiggerLin]

llvm/include/llvm/MC/MCSymbolGOFF.h

21

I am not sure the purpose of using mutable here ,just want to keep as MCSymbol did?

if we do not use the mutable here, we do not need the "const" in

void setAlignment(Align Value) const

llvm/lib/MC/GOFFObjectWriter.cpp

249

suggest to change the construct to

GOFFSymbol(const std::string& Name, ......)

Since in most of your cases, when you create GOFFSymbol, the parameter is std::string , using const std::string& Name
in your construct, it can avoid from std::string to StringRef and from StringRef to std::string again.

for example in your following test case:
RootSD = createSDSymbol(FileName.str().append("#C"));
of course ,
you also need to change createSDSymbol(StringRef Name) to
:createSDSymbol(const std::string Name)

472

change to

GOFFSymbol *ADAED = createWSASymbol(RootSD->EsdId);

500

SD to SDSym ?
and also for ED to EDSym?
...

521

change to
StringRef SectionName = Section.getName(); to avoid string construct and copy.

546

Symbol too generic
change to
const MCSymbolGOFF &MCSym ?

585

LD->ADAEsdId = (ADA && ADA->SectionLength > 0 ? ADA->EsdId : 0);

608

GSection->SD , the SD is to generic , I do not know the type of GSection->SD at first glance, I have to go back and check the Type the GSection->SD, if change the name SD to SDSym in the definition, from the name, at least we know it is a symbol related

and add assert(GSection->SD ) , otherwise if GSection->SD is nullptr, it will be crash.

691

I am expressing the difficulty in understanding the meaning or significance of the values 0, 8 in a particular context. it's possible to use a "static constexpr" to define these values to provide more clarity and context?

if can , please change all the following .

for example: in xcoff.h

constexpr size_t FileNamePadSize = 6;
constexpr size_t NameSize = 8;
constexpr size_t FileHeaderSize32 = 20;
constexpr size_t FileHeaderSize64 = 24;

725

do not use inline struct here, using lambda functions here.

834

change to
StringRef Name = Res.str();

and delete line 845

StringRef Name;

[Everybody0523]

llvm/lib/MC/GOFFObjectWriter.cpp

691

So in the highlighted function (setAmode), we're setting the address mode of the symbol, which is an 8-bit field. The first parameter of the set() function is the offset to which we begin, the second parameter is the number of bits that should be written, and the last value is the actual value to write, so in this case we just mean "0-bit offset" and "write 8 bits" for the 0 and 8 respectively.

[DiggerLin]

llvm/lib/MC/GOFFObjectWriter.cpp

691

sorry that I do not express my comment clearly. My worry about is that your code is not easy to understand without reading the GOFF document.

can we change the code something like ?

struct SymbolBehavAttr {
  uint8_t AddressingProperties;
  uint8_t ResidenceProperties;
  uint8_t TextRecordtyle:4;
  uint8_t BindingAlgorithm:4;
  ....
}  ;

(and if the SymbolBehavAttr will be by other functionality later, we can put it GOFF.h ?)

and then you do not need the API setRmode() and setAmode()
and you can assign the value directly

SymbolBehavAttr BehavAttr;
BehavAttr.AddressingProperties = ...

725

please ignore my about comment.

860

can you add a new api for GOFFOstream for the size which large than 64bits ?
something like

https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/EndianStream.h#L46 ?

897

change

for (unsigned I = 0; I < Size; ++I) {
      Data.append(1, '\0');

to

Data.append(Size, '\0');

923

change to ++I;

[DiggerLin]

llvm/lib/MC/GOFFObjectWriter.cpp

462

the value of CsectNames never be set , the default value of CsectNames here for Asm.getCsectNames(). ?

875

add a lambda help function before case MCFragment::FT_Data:

for example:

 auto GenericFragWriteHelper = [](const T& Fragment ) {
      const SmallVectorImpl<char> &Data = DataFrag.getContents();
      size_t SectionOffset = Layout.getFragmentOffset(&Fragment);
      bufferText(Section, SectionOffset, Data);
  }

case MCFragment::FT_Data: {
     GenericFragWriteHelper(static_cast<const MCDataFragment &>(Fragment));
     break;
.....
   case MCFragment::FT_Dwarf:
     GenericFragWriteHelper(static_cast<const MCDataFragment &>(Fragment));
     break;
 }

and also can be used for MCFragment::FT_LEB:

[DiggerLin]

llvm/lib/MC/GOFFObjectWriter.cpp

871

I am not familiar with GOFF, I am curious that why we can not use the API defined at https://llvm.org/doxygen/MCAssembler_8cpp_source.html#l00730 to write the section date as XCOFF and ELF?

if we can not use the API

void writeSectionData(raw_ostream &OS, const MCSection *Section, const MCAsmLayout &Layout) const;

,it will be useful to add some comment to explain why?

and the code

static void writeFragment(raw_ostream &OS, const MCAssembler &Asm,
                         const MCAsmLayout &Layout, const MCFragment &F)

https://llvm.org/doxygen/MCAssembler_8cpp_source.html#l00512 deal with all different Fragment Kind.

955

the GOFF has text section and data section ? if has , change the name to write writeSection ?

[kpn]

llvm/lib/MC/GOFFObjectWriter.cpp

923

Is this a documented standard? Because pre- and post- are widely used in the codebase.

955

GOFF, and the mainframe in general, uses words differently from the Unix world. Sometimes it's the same word, and sometimes different words are used for similar concepts.

GOFF sections are SD symbols that have ED symbols as children. Text is owned by either an ED or PR symbol. Multiple blobs of text (TXT records) can exist in the same SD, probably owned by different symbols under that SD. Which means that "writing a section" doesn't mean what it means on other targets.

I'd say "writeText()" is the best name for this function. I admit it's a bit of a trick moving back and forth from the part of the LLVM codebase that comes from the Unix world to the GOFF codebase from the mainframe world. But inside a class named GOFFObjectWriter I'd suggest sticking with GOFF naming and conventions whenever possible.

[DiggerLin]

llvm/lib/MC/GOFFObjectWriter.cpp

923

https://llvm.org/docs/CodingStandards.html#prefer-preincrement

[Everybody0523]

llvm/lib/MC/GOFFObjectWriter.cpp

691

Hi, so I guess you would want something like this?

LLVM_PACKED_START
struct SymbolBehavAttr {
  uint8_t AddressingProperties;
  uint8_t ResidenceProperties;
  uint8_t TextRecordStyle:4; //Byte 2 begin
  uint8_t BindingAlgorithm:4;
  uint8_t TaskingBehavior:3; //Byte 3 begin
  uint8_t ReservedSpace0:1;
  uint8_t ReadOnlyIndicator:1;
  uint8_t Executable:3;
  uint8_t ReservedSpace1:2; //Byte 4 begin
  uint8_t DuplicateSymbolSeverity:2;
  uint8_t BindingStrength:4; 
  uint8_t ClassLoadingBehavior:2; //Byte 5 begin
  uint8_t CommonFlag:1;
  uint8_t IsDirectReference:1;
  uint8_t BindingScope:4;
  uint8_t ReservedSpace2:3; //Byte 6 begin
  uint8_t LinkageType:1;
  uint8_t Alignment:5;
  uint8_t ReservedSpace3; 
  uint16_t ReservedSpace4;
};
LLVM_PACKED_END

[Everybody0523]

llvm/lib/MC/GOFFObjectWriter.cpp

691

(meant to send htis as part of above message, idk what happened ¯\_(ツ)_/¯)

I can see how this self-documents the format of the Behavior Attributes field in GOFF, which is nice, but I do find it annoying that I'd need to fill out the reserved bytes in order to ensure the format is correct...

[DiggerLin]

llvm/lib/MC/GOFFObjectWriter.cpp

691

yes. in xcoff, there is example:

struct XCOFFBlockAuxEnt32 {
  uint8_t ReservedZeros1[2];
  support::ubig16_t LineNumHi;
  support::ubig16_t LineNumLo;
  uint8_t ReservedZeros2[12];
};

we do not care about the value of the reserved bytes since it is resevered. is it special in GOFF ?

[kpn]

llvm/lib/MC/GOFFObjectWriter.cpp

691

Reserved bytes should be written out as zeros to prevent unpredictable behavior in future versions of GOFF.

Writing out uninitialized memory is also generally considered to be a security issue because we're letting an attacker see what is in memory. Now, I can't think of a case where this is useful, but if an attacker has a financial interest in being smarter than me an attacker is going to be smarter than me. Let's not introduce any new security issues on purpose.

[Everybody0523]

• Some variable renaming
• Use Asm.writeSectionData() API
• Use of lambdas function in a few places.
• Zero-initialize records.

[Everybody0523]

Get rid of deprecated field ESDERSymbolType.

[Everybody0523]

Since Oct 1 is fast-approaching, I have opened https://github.com/llvm/llvm-project/pull/67868 to "move" the code review to github.

llvm/include/llvm/BinaryFormat/GOFF.h

 
 enum ESDReserveQwords : uint8_t {
   ESD_RQ_0 = 0,
   ESD_RQ_1 = 1,
   ESD_RQ_2 = 2,
   ESD_RQ_3 = 3
 };
 
+enum ESDERSymbolType : uint8_t {
+  ESD_ES_None = 0,
+  ESD_ES_Section = 1,
+  ESD_ES_Label = 2,
+  ESD_ES_Class = 3,
+  ESD_ES_Part = 4
+};
+
 enum ESDAmode : uint8_t {
   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 ESDAlignment : uint8_t {
   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 : uint8_t {
+  TXT_RS_Byte = 0,
+  TXT_RS_Structured = 1,
+  TXT_RS_Unstructured = 2,
+};
+
 enum ENDEntryPointRequest : uint8_t {
   END_EPR_None = 0,
   END_EPR_EsdidOffset = 1,
   END_EPR_ExternalName = 2,
   END_EPR_Reserved = 3,
 };
 
 // \brief Subsections of the primary C_CODE section in the object file.
 enum SubsectionKind : uint8_t {
   SK_PPA1 = 2,
 };
 } // end namespace GOFF
 
 } // end namespace llvm
 
 #endif // LLVM_BINARYFORMAT_GOFF_H

llvm/include/llvm/MC/MCAssembler.h

private:
   std::vector<DataRegionData> DataRegions;
 
   /// The list of linker options to propagate into the object file.
   std::vector<std::vector<std::string>> LinkerOptions;
 
   /// List of declared file names
   std::vector<std::pair<std::string, size_t>> FileNames;
 
+  /// GOFF Csect names.
+  std::pair<std::string, std::string> CsectNames;
+
   MCDwarfLineTableParams LTParams;
 
   /// The set of function symbols for which a .thumb_func directive has
   /// been seen.
   //
   // FIXME: We really would like this in target specific code rather than
   // here. Maybe when the relocation stuff moves to target specific,
   // this can go with it? The streamer would need some target specific
public:
   MutableArrayRef<std::pair<std::string, size_t>> getFileNames() {
     return FileNames;
   }
 
   void addFileName(StringRef FileName) {
     FileNames.emplace_back(std::string(FileName), Symbols.size());
   }
 
+  std::pair<std::string, std::string> const &getCsectNames() { return CsectNames; }
+
   /// Write the necessary bundle padding to \p OS.
   /// Expects a fragment \p F containing instructions and its size \p FSize.
   void writeFragmentPadding(raw_ostream &OS, const MCEncodedFragment &F,
                             uint64_t FSize) const;
 
   /// @}
 
   void dump() const;
 };

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"
+#include "llvm/Support/Casting.h"
 
 namespace llvm {
 class MCObjectWriter;
 class raw_pwrite_stream;
 
 class MCGOFFObjectTargetWriter : public MCObjectTargetWriter {
 protected:
   MCGOFFObjectTargetWriter() = default;

llvm/include/llvm/MC/MCGOFFStreamer.h

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;
-  }
+  // state management
+  void initSections(bool NoExecStack, const MCSubtargetInfo &STI) override;
+
+  void switchSection(MCSection *Section,
+                     const MCExpr *Subsection = nullptr) override;
+
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   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/MCSymbolGOFF.h

 #ifndef LLVM_MC_MCSYMBOLGOFF_H
 #define LLVM_MC_MCSYMBOLGOFF_H
 
 #include "llvm/MC/MCSymbol.h"
 
 namespace llvm {
 
 class MCSymbolGOFF : public MCSymbol {
+  Align Alignment;
+  enum SymbolFlags : uint16_t {
+    SF_NoRent = 0x01, // Symbol is no-reentrant.
+    SF_Alias = 0x02,  // Symbol is alias.
+    SF_Hidden = 0x04, // Symbol is hidden, aka not exported.
+    SF_Weak = 0x08,   // Symbol is weak.
+  };
+
+  enum {
+    // Shift value for GOFF::ESDExecutable. 3 possible values. 2 bits.
+    GOFF_Executable_Shift = 6,
+    GOFF_Executable_Bitmask = 0x3,
+  };
+
 public:
   MCSymbolGOFF(const StringMapEntry<bool> *Name, bool IsTemporary)
       : MCSymbol(SymbolKindGOFF, Name, IsTemporary) {}
   static bool classof(const MCSymbol *S) { return S->isGOFF(); }
+
+  void setAlignment(Align Value) { Alignment = Value; }
+  Align getAlignment() const { return Alignment; }
+
+  void setExecutable(GOFF::ESDExecutable Value) const {
+    modifyFlags(Value << GOFF_Executable_Shift,
+                GOFF_Executable_Bitmask << GOFF_Executable_Shift);
+  }
+  GOFF::ESDExecutable getExecutable() const {
+    return static_cast<GOFF::ESDExecutable>(
+        (getFlags() >> GOFF_Executable_Shift) & GOFF_Executable_Bitmask);
+  }
+
+  void setHidden(bool Value = true) {
+    modifyFlags(Value ? SF_Hidden : 0, SF_Hidden);
+  }
+  bool isHidden() const { return getFlags() & SF_Hidden; }
+  bool isExported() const { return !isHidden(); }
+
+  void setWeak(bool Value = true) { modifyFlags(Value ? SF_Weak : 0, SF_Weak); }
+  bool isWeak() const { return getFlags() & SF_Weak; }
+
+  void setAlias(bool Value = true) {
+    modifyFlags(Value ? SF_Alias : 0, SF_Alias);
+  }
+  bool isAlias() const { return getFlags() & SF_Alias; }
 };
 } // end namespace llvm
 
 #endif

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/MCContext.h"
 #include "llvm/MC/MCGOFFObjectWriter.h"
+#include "llvm/MC/MCSectionGOFF.h"
+#include "llvm/MC/MCSymbolGOFF.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/ConvertEBCDIC.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"

 // writing data in big endian byte order.
 class GOFFOstream : 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 start of new record.
OS << static_cast<unsigned char>(GOFF::PTVPrefix) // Record Type
      << static_cast<unsigned char>(TypeAndFlags)    // Continuation
      << static_cast<unsigned char>(0);              // Version
 }
 
 void GOFFOstream::newRecord(GOFF::RecordType Type, size_t Size) {
   fillRecord();
   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;
 }
while (Size > 0) {
     Idx += BytesToWrite;
     Size -= BytesToWrite;
     RemainingSize -= BytesToWrite;
     if (Size)
       writeRecordPrefix(OS, CurrentType, RemainingSize);
   }
 }
 
+/// \brief Wrapper class for symbols used exclusively for the symbol table in a
+/// GOFF file.
+class GOFFSymbol {
+public:
+  std::string Name;
+  uint32_t EsdId;
+  uint32_t ParentEsdId;
+  const MCSymbolGOFF *MCSym;
+  GOFF::ESDSymbolType SymbolType;
+
+  GOFF::ESDNameSpaceId NameSpace = GOFF::ESD_NS_NormalName;
+  GOFF::ESDAmode Amode = GOFF::ESD_AMODE_64;
+  GOFF::ESDRmode Rmode = GOFF::ESD_RMODE_64;
+  GOFF::ESDLinkageType Linkage = GOFF::ESD_LT_XPLink;
+  GOFF::ESDExecutable Executable = GOFF::ESD_EXE_Unspecified;
+  GOFF::ESDAlignment Alignment = GOFF::ESD_ALIGN_Byte;
+  GOFF::ESDTextStyle TextStyle = GOFF::ESD_TS_ByteOriented;
+  GOFF::ESDBindingAlgorithm BindAlgorithm = GOFF::ESD_BA_Concatenate;
+  GOFF::ESDLoadingBehavior LoadBehavior = GOFF::ESD_LB_Initial;
+  GOFF::ESDBindingScope BindingScope = GOFF::ESD_BSC_Unspecified;
+  GOFF::ESDBindingStrength BindingStrength = GOFF::ESD_BST_Strong;
+  uint32_t SortKey = 0;
+  uint32_t SectionLength = 0;
+  uint32_t ADAEsdId = 0;
+  bool Indirect = false;
+  bool ForceRent = false;
+  bool Renamable = false;
+  bool ReadOnly = false;
+  uint32_t EASectionEsdId = 0;
+  uint32_t EASectionOffset = 0;
+
+  GOFFSymbol(StringRef Name, GOFF::ESDSymbolType Type, uint32_t EsdID,
+             uint32_t ParentEsdID)
+      : Name(Name.data(), Name.size()), EsdId(EsdID), ParentEsdId(ParentEsdID),
+        MCSym(nullptr), SymbolType(Type) {}
+
+  bool isForceRent() const { return ForceRent; }
+  bool isReadOnly() const { return ReadOnly; }
+  bool isRemovable() const { return false; }
+  bool isExecutable() const { return Executable == GOFF::ESD_EXE_CODE; }
+  bool isExecUnspecified() const {
+    return Executable == GOFF::ESD_EXE_Unspecified;
+  }
+  bool isWeakRef() const { return BindingStrength == GOFF::ESD_BST_Weak; }
+  bool isExternal() const {
+    return (BindingScope == GOFF::ESD_BSC_Library) ||
+           (BindingScope == GOFF::ESD_BSC_ImportExport);
+  }
+
+  void setAlignment(Align A) {
+    // The GOFF alignment is encoded as log_2 value.
+    uint8_t Log = Log2(A);
+    if (Log <= GOFF::ESD_ALIGN_4Kpage)
+      Alignment = static_cast<GOFF::ESDAlignment>(Log);
+    else
+      llvm_unreachable("Unsupported alignment");
+  }
+
+  void setMaxAlignment(Align A) {
+    GOFF::ESDAlignment CurrAlign = Alignment;
+    setAlignment(A);
+    if (CurrAlign > Alignment)
+      Alignment = CurrAlign;
+  }
+};
+
+/// \brief Wrapper class for sections used exclusively for representing sections
+/// of the GOFF output that have actual bytes.  This could be a ED or a PR.
+/// Relocations will always have a P-pointer to the ESDID of one of these.
+class GOFFSection {
+public:
+  GOFFSymbol *Pptr = nullptr;
+  GOFFSymbol *Rptr = nullptr;
+  GOFFSymbol *SD = nullptr;
+  const MCSectionGOFF *MCSec = nullptr;
+  bool IsStructured = false;
+
+  GOFFSection(GOFFSymbol *Pptr, GOFFSymbol *Rptr, GOFFSymbol *SD,
+              const MCSectionGOFF *MCSec)
+      : Pptr(Pptr), Rptr(Rptr), SD(SD), MCSec(MCSec), IsStructured(false) {}
+};
+
 class GOFFObjectWriter : public MCObjectWriter {
+  typedef std::vector<std::unique_ptr<GOFFSymbol>> SymbolListType;
+  typedef DenseMap<MCSymbol const *, GOFFSymbol *> SymbolMapType;
+  typedef std::vector<std::unique_ptr<GOFFSection>> SectionListType;
+  typedef DenseMap<MCSection const *, GOFFSection *> SectionMapType;
+
   // The target specific GOFF writer instance.
   std::unique_ptr<MCGOFFObjectTargetWriter> TargetObjectWriter;
 
+  /// The symbol table for a GOFF file.  It is order sensitive.
+  SymbolListType EsdSymbols;
+
+  /// Lookup table for MCSymbols to GOFFSymbols.  Needed to determine EsdIds
+  /// of symbols in Relocations.
+  SymbolMapType SymbolMap;
+
+  /// The list of sections for the GOFF file.
+  SectionListType Sections;
+
+  /// Lookup table for MCSections to GOFFSections.  Needed to determine
+  /// SymbolType on GOFFSymbols that reside in GOFFSections.
+  SectionMapType SectionMap;
+
   // The stream used to write the GOFF records.
   GOFFOstream OS;
 
+  uint32_t EsdCounter = 1;
+
+  GOFFSymbol *RootSD = nullptr;
+  GOFFSymbol *CodeLD = nullptr;
+  GOFFSymbol *ADA = nullptr;
+  bool HasADA = false;
+
 public:
   GOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW,
                    raw_pwrite_stream &OS)
       : TargetObjectWriter(std::move(MOTW)), OS(OS) {}
 
   ~GOFFObjectWriter() override {}
 
+private:
   // Write GOFF records.
   void writeHeader();
+
+  void writeSymbol(const GOFFSymbol &Symbol, const MCAsmLayout &Layout);
+  void writeText(const GOFFSection &Section, const MCAssembler &Asm,
+                 const MCAsmLayout &Layout);
+
   void writeEnd();
 
+public:
   // 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 {}
+                                const MCAsmLayout &Layout) override;
   uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+
+private:
+  GOFFSection *createGOFFSection(GOFFSymbol *Pptr, GOFFSymbol *Rptr,
+                                 GOFFSymbol *SD, const MCSectionGOFF *MC);
+  GOFFSymbol *createGOFFSymbol(StringRef Name, GOFF::ESDSymbolType Type,
+                               uint32_t ParentEsdId);
+  GOFFSymbol *createSDSymbol(StringRef Name);
+  GOFFSymbol *createEDSymbol(StringRef Name, uint32_t ParentEsdId);
+  GOFFSymbol *createLDSymbol(StringRef Name, uint32_t ParentEsdId);
+  GOFFSymbol *createERSymbol(StringRef Name, uint32_t ParentEsdId,
+                             const MCSymbolGOFF *Source = nullptr);
+  GOFFSymbol *createPRSymbol(StringRef Name, uint32_t ParentEsdId);
+
+  GOFFSymbol *createWSASymbol(uint32_t ParentEsdId);
+  void defineRootAndADASD(MCAssembler &Asm);
+  void defineSectionSymbols(const MCAssembler &Asm, const MCSectionGOFF &Section,
+                            const MCAsmLayout &Layout);
+  void processSymbolDefinedInModule(const MCSymbolGOFF &MCSymbol,
+                                    const MCAssembler &Asm,
+                                    const MCAsmLayout &Layout);
+  void processSymbolDeclaredInModule(const MCSymbolGOFF &Symbol);
 };
 } // end anonymous namespace
 
+GOFFSection *GOFFObjectWriter::createGOFFSection(GOFFSymbol *Pptr,
+                                                 GOFFSymbol *Rptr,
+                                                 GOFFSymbol *SD,
+                                                 const MCSectionGOFF *MC) {
+  Sections.push_back(std::make_unique<GOFFSection>(Pptr, Rptr, SD, MC));
+
+  return Sections.back().get();
+}
+
+GOFFSymbol *GOFFObjectWriter::createGOFFSymbol(StringRef Name,
+                                               GOFF::ESDSymbolType Type,
+                                               uint32_t ParentEsdId) {
+  EsdSymbols.push_back(
+      std::make_unique<GOFFSymbol>(Name, Type, EsdCounter, ParentEsdId));
+  ++EsdCounter;
+  return EsdSymbols.back().get();
+}
+
+GOFFSymbol *GOFFObjectWriter::createSDSymbol(StringRef Name) {
+  return createGOFFSymbol(Name, GOFF::ESD_ST_SectionDefinition, 0);
+}
+
+GOFFSymbol *GOFFObjectWriter::createEDSymbol(StringRef Name,
+                                             uint32_t ParentEsdId) {
+  GOFFSymbol *ED =
+      createGOFFSymbol(Name, GOFF::ESD_ST_ElementDefinition, ParentEsdId);
+
+  ED->Alignment = GOFF::ESD_ALIGN_Doubleword;
+  return ED;
+}
+
+GOFFSymbol *GOFFObjectWriter::createLDSymbol(StringRef Name,
+                                             uint32_t ParentEsdId) {
+  return createGOFFSymbol(Name, GOFF::ESD_ST_LabelDefinition, ParentEsdId);
+}
+
+GOFFSymbol *GOFFObjectWriter::createERSymbol(StringRef Name,
+                                             uint32_t ParentEsdId,
+                                             const MCSymbolGOFF *Source) {
+  GOFFSymbol *ER =
+      createGOFFSymbol(Name, GOFF::ESD_ST_ExternalReference, ParentEsdId);
+
+  if (Source) {
+    ER->Linkage = GOFF::ESDLinkageType::ESD_LT_XPLink;
+    ER->Executable = Source->getExecutable();
+    ER->BindingScope = Source->isExternal()
+                           ? GOFF::ESDBindingScope::ESD_BSC_Library
+                           : GOFF::ESDBindingScope::ESD_BSC_Section;
+    ER->BindingStrength = Source->isWeak()
+                              ? GOFF::ESDBindingStrength::ESD_BST_Weak
+                              : GOFF::ESDBindingStrength::ESD_BST_Strong;
+  }
+
+  return ER;
+}
+
+GOFFSymbol *GOFFObjectWriter::createPRSymbol(StringRef Name,
+                                             uint32_t ParentEsdId) {
+  return createGOFFSymbol(Name, GOFF::ESD_ST_PartReference, ParentEsdId);
+}
+
+GOFFSymbol *GOFFObjectWriter::createWSASymbol(uint32_t ParentEsdId) {
+  const char *WSAClassName = "C_WSA64";
+  GOFFSymbol *WSA = createEDSymbol(WSAClassName, ParentEsdId);
+
+  WSA->Executable = GOFF::ESD_EXE_DATA;
+  WSA->TextStyle = GOFF::ESD_TS_ByteOriented;
+  WSA->BindAlgorithm = GOFF::ESD_BA_Merge;
+  WSA->Alignment = GOFF::ESD_ALIGN_Quadword;
+  WSA->LoadBehavior = GOFF::ESD_LB_Deferred;
+  WSA->NameSpace = GOFF::ESD_NS_Parts;
+  WSA->SectionLength = 0;
+
+  return WSA;
+}
+
+void GOFFObjectWriter::defineRootAndADASD(MCAssembler &Asm) {
+  assert(!RootSD && !ADA && "SD already initialzed");
+  StringRef FileName = sys::path::stem((*(Asm.getFileNames().begin())).first);
+  std::pair<std::string, std::string> CsectNames = Asm.getCsectNames();
+  if (CsectNames.first.empty()) {
+    RootSD = createSDSymbol(FileName.str().append("#C"));
+    RootSD->BindingScope = GOFF::ESD_BSC_Section;
+  } else {
+    RootSD = createSDSymbol(CsectNames.first);
+  }
+  RootSD->Executable = GOFF::ESD_EXE_CODE;
+
+  GOFFSymbol *ADAED = createWSASymbol(RootSD->EsdId);
+  if (CsectNames.second.empty()) {
+    ADA = createPRSymbol(FileName.str().append("#S"), ADAED->EsdId);
+    ADA->BindingScope = GOFF::ESD_BSC_Section;
+  } else {
+    ADA = createPRSymbol(CsectNames.second, ADAED->EsdId);
+    ADA->BindingScope = GOFF::ESD_BSC_Library;
+  }
+  ADA->Executable = GOFF::ESD_EXE_DATA;
+  ADA->NameSpace = GOFF::ESD_NS_Parts;
+  ADA->Alignment = GOFF::ESD_ALIGN_Quadword;
+  // The ADA Section length can increase after this point. The final ADA
+  // length is assigned in populateADASection().
+  // We need to be careful, because a value of 0 causes issues with function
+  // labels. In populateADASection(), we make sure that the ADA content is
+  // defined before createing function labels.
+  ADA->SectionLength = 0;
+  // Assume there is an ADA.
+  HasADA = true;
+}
+
+void GOFFObjectWriter::defineSectionSymbols(const MCAssembler &Asm,
+                                            const MCSectionGOFF &Section,
+                                            const MCAsmLayout &Layout) {
+  GOFFSection *GSection = nullptr;
+  SectionKind Kind = Section.getKind();
+
+  if (Kind.isText()) {
+    GOFFSymbol *SD = RootSD;
+    const char *CodeClassName = "C_CODE64";
+    GOFFSymbol *ED = createEDSymbol(CodeClassName, SD->EsdId);
+    GOFFSymbol *LD = createLDSymbol(SD->Name, ED->EsdId);
+
+    ED->SectionLength = Layout.getSectionAddressSize(&Section);
+    ED->Executable = GOFF::ESD_EXE_CODE;
+    ED->ForceRent = true;
+
+    LD->Executable = GOFF::ESD_EXE_CODE;
+    if (SD->BindingScope == GOFF::ESD_BSC_Section) {
+      LD->BindingScope = GOFF::ESD_BSC_Section;
+    } else {
+      LD->BindingScope = GOFF::ESD_BSC_Library;
+    }
+
+    CodeLD = LD;
+
+    GSection = createGOFFSection(ED, LD, SD, &Section);
+  } else if (Kind.isBSS() || Kind.isData()) {
+    // Statics and globals that are defined.
+    StringRef SectionName = Section.getName();
+    GOFFSymbol *SD = createSDSymbol(SectionName);
+
+    // Determine if static/global variable is marked with the norent attribute.
+    MCContext &Ctx = Asm.getContext();
+    auto *Sym = cast_or_null<MCSymbolGOFF>(Ctx.lookupSymbol(SectionName));
+
+    if (Sym) {
+      GOFFSymbol *ED = createWSASymbol(SD->EsdId);
+      GOFFSymbol *PR = createPRSymbol(SectionName, ED->EsdId);
+      ED->Alignment =
+          std::max(static_cast<GOFF::ESDAlignment>(Log2(Section.getAlign())),
+                   GOFF::ESD_ALIGN_Quadword);
+
+      PR->Executable = GOFF::ESD_EXE_DATA;
+      PR->NameSpace = GOFF::ESD_NS_Parts;
+
+      GSection = createGOFFSection(PR, PR, SD, &Section);
+    }
+  } else
+    llvm_unreachable("Unhandled section kind");
+
+  SectionMap[&Section] = GSection;
+}
+
+void GOFFObjectWriter::processSymbolDefinedInModule(const MCSymbolGOFF &MCSymbol,
+                                                    const MCAssembler &Asm,
+                                                    const MCAsmLayout &Layout) {
+  MCSection &Section = MCSymbol.getSection();
+  SectionKind Kind = Section.getKind();
+  auto &Sec = cast<MCSectionGOFF>(Section);
+
+  GOFFSection *GSection = SectionMap[&Sec];
+  assert(GSection && "No corresponding section found");
+
+  GOFFSymbol *GSectionSym = GSection->Pptr;
+  assert(GSectionSym &&
+         "Defined symbols must exist in an initialized GSection");
+
+  StringRef SymbolName = MCSymbol.getName();
+  // If it's a text section, then create a label for it.
+  if (Kind.isText()) {
+    GOFFSymbol *LD = createLDSymbol(SymbolName, GSectionSym->EsdId);
+    LD->BindingStrength = MCSymbol.isWeak()
+                              ? GOFF::ESDBindingStrength::ESD_BST_Weak
+                              : GOFF::ESDBindingStrength::ESD_BST_Strong;
+
+    // If we don't know if it is code or data, assume it is code.
+    LD->Executable = MCSymbol.getExecutable();
+    if (LD->isExecUnspecified())
+      LD->Executable = GOFF::ESD_EXE_CODE;
+
+    // Determine the binding scope. Please note that the combination
+    // !isExternal && isExported makes no sense.
+    LD->BindingScope = MCSymbol.isExternal()
+                           ? (MCSymbol.isExported()
+                                  ? GOFF::ESD_BSC_ImportExport
+                                  : (LD->isExecutable() ? GOFF::ESD_BSC_Library
+                                                        : GOFF::ESD_BSC_Module))
+                           : GOFF::ESD_BSC_Section;
+
+    if (ADA && ADA->SectionLength > 0)
+      LD->ADAEsdId = ADA->EsdId;
+    else
+      LD->ADAEsdId = 0;
+
+    GSectionSym->setMaxAlignment(MCSymbol.getAlignment());
+
+    LD->MCSym = &MCSymbol;
+    SymbolMap[&MCSymbol] = LD;
+  } else if (Kind.isBSS() || Kind.isData()) {
+    GSectionSym = GSection->Rptr;
+    GSectionSym->BindingScope =
+        MCSymbol.isExternal() ? (MCSymbol.isExported() ? GOFF::ESD_BSC_ImportExport
+                                                   : GOFF::ESD_BSC_Library)
+                            : GOFF::ESD_BSC_Section;
+    if (GSectionSym->BindingScope == GOFF::ESD_BSC_Section)
+      GSection->SD->BindingScope = GOFF::ESD_BSC_Section;
+    GSectionSym->setAlignment(MCSymbol.getAlignment());
+    GSectionSym->SectionLength = Layout.getSectionAddressSize(&Section);
+
+    // We cannot have a zero-length section for data.  If we do, artificially
+    // inflate it.  Use 2 bytes to avoid odd alignments.
+    if (!GSectionSym->SectionLength)
+      GSectionSym->SectionLength = 2;
+
+    GSectionSym->MCSym = &MCSymbol;
+    GSection->SD->MCSym = &MCSymbol;
+    SymbolMap[&MCSymbol] = GSectionSym;
+  } else
+    llvm_unreachable("Unhandled section kind for Symbol");
+}
+
+void GOFFObjectWriter::processSymbolDeclaredInModule(
+    const MCSymbolGOFF &Symbol) {
+  GOFFSymbol *SD = RootSD;
+
+  switch (Symbol.getExecutable()) {
+  case GOFF::ESD_EXE_CODE:
+  case GOFF::ESD_EXE_Unspecified: {
+    GOFFSymbol *ER = createERSymbol(Symbol.getName(), SD->EsdId, &Symbol);
+    ER->BindingScope = GOFF::ESD_BSC_ImportExport;
+    ER->MCSym = &Symbol;
+    SymbolMap[&Symbol] = ER;
+    break;
+  }
+  case GOFF::ESD_EXE_DATA: {
+    GOFFSymbol *ED = createWSASymbol(SD->EsdId);
+    ED->setAlignment(Symbol.getAlignment());
+    GOFFSymbol *PR = createPRSymbol(Symbol.getName(), ED->EsdId);
+
+    PR->BindingScope = GOFF::ESD_BSC_ImportExport;
+    PR->setAlignment(Symbol.getAlignment());
+    PR->NameSpace = GOFF::ESD_NS_Parts;
+    PR->SectionLength = 0;
+    PR->MCSym = &Symbol;
+    SymbolMap[&Symbol] = PR;
+    break;
+  }
+  }
+}
+
+void GOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
+                                                const MCAsmLayout &Layout) {
+  LLVM_DEBUG(dbgs() << "Entering " << __FUNCTION__ << "\n");
+
+  // Define the GOFF root and ADA symbol.
+  defineRootAndADASD(Asm);
+
+  for (MCSection &S : Asm) {
+    auto &Section = cast<MCSectionGOFF>(S);
+    LLVM_DEBUG(dbgs() << "Current Section (" << Section.getName() << "): ";
+               Section.dump(); dbgs() << '\n');
+    defineSectionSymbols(Asm, Section, Layout);
+  }
+
+  for (const MCSymbol &Sym : Asm.symbols()) {
+    if (Sym.isTemporary() && !Sym.isUsedInReloc())
+      continue;
+
+    auto &Symbol = cast<MCSymbolGOFF>(Sym);
+    if (Symbol.isDefined())
+      processSymbolDefinedInModule(Symbol, Asm, Layout);
+    else
+      processSymbolDeclaredInModule(Symbol);
+  }
+}
+
 void GOFFObjectWriter::writeHeader() {
   OS.newRecord(GOFF::RT_HDR, /*Size=*/57);
   OS.write_zeros(1);       // Reserved
   OS.writeBE<uint32_t>(0); // Target Hardware Environment
   OS.writeBE<uint32_t>(0); // Target Operating System Environment
   OS.write_zeros(2);       // Reserved
   OS.writeBE<uint16_t>(0); // CCSID
   OS.write_zeros(16);      // Character Set name
   OS.write_zeros(16);      // Language Product Identifier
   OS.writeBE<uint32_t>(1); // Architecture Level
   OS.writeBE<uint16_t>(0); // Module Properties Length
   OS.write_zeros(6);       // Reserved
 }
 
+void GOFFObjectWriter::writeSymbol(const GOFFSymbol &Symbol,
+                                   const MCAsmLayout &Layout) {
+  uint32_t Offset = 0;
+  uint32_t Length = 0;
+  GOFF::ESDNameSpaceId NameSpaceId = GOFF::ESD_NS_ProgramManagementBinder;
+  Flags SymbolFlags;
+  uint8_t FillByteValue = 0;
+
+  Flags BehavAttrs[10] = {};
+  auto setAmode = [&BehavAttrs](GOFF::ESDAmode Amode) { BehavAttrs[0].set(0, 8, Amode); };
+  auto setRmode = [&BehavAttrs](GOFF::ESDRmode Rmode) { BehavAttrs[1].set(0, 8, Rmode); };
+  auto setTextStyle = [&BehavAttrs](GOFF::ESDTextStyle Style) { BehavAttrs[2].set(0, 4, Style); };
+  auto setBindingAlgorithm = [&BehavAttrs](GOFF::ESDBindingAlgorithm Algorithm) {
+    BehavAttrs[2].set(4, 4, Algorithm);
+  };
+  auto setTaskingBehavior = [&BehavAttrs](GOFF::ESDTaskingBehavior TaskingBehavior) {
+    BehavAttrs[3].set(0, 3, TaskingBehavior);
+  };
+  auto setReadOnly = [&BehavAttrs](bool ReadOnly) { BehavAttrs[3].set(4, 1, ReadOnly); };
+  auto setExecutable = [&BehavAttrs](GOFF::ESDExecutable Executable) {
+    BehavAttrs[3].set(5, 3, Executable);
+  };
+  auto setDuplicateSeverity = [&BehavAttrs](GOFF::ESDDuplicateSymbolSeverity DSS) {
+    BehavAttrs[4].set(2, 2, DSS);
+  };
+  auto setBindingStrength = [&BehavAttrs](GOFF::ESDBindingStrength Strength) {
+    BehavAttrs[4].set(4, 4, Strength);
+  };
+  auto setLoadingBehavior = [&BehavAttrs](GOFF::ESDLoadingBehavior Behavior) {
+    BehavAttrs[5].set(0, 2, Behavior);
+  };
+  auto setIndirectReference = [&BehavAttrs](bool Indirect) {
+    uint8_t Value = Indirect ? 1 : 0;
+    BehavAttrs[5].set(3, 1, Value);
+  };
+  auto setBindingScope = [&BehavAttrs](GOFF::ESDBindingScope Scope) {
+    BehavAttrs[5].set(4, 4, Scope);
+  };
+  auto setLinkageType = [&BehavAttrs](GOFF::ESDLinkageType Type) { BehavAttrs[6].set(2, 1, Type); };
+  auto setAlignment = [&BehavAttrs](GOFF::ESDAlignment Alignment) {
+    BehavAttrs[6].set(3, 5, Alignment);
+  };
+
+  uint32_t AdaEsdId = 0;
+  uint32_t SortPriority = 0;
+
+  switch (Symbol.SymbolType) {
+  case GOFF::ESD_ST_SectionDefinition: {
+    if (Symbol.isExecutable()) // Unspecified otherwise
+      setTaskingBehavior(GOFF::ESD_TA_Rent);
+    if (Symbol.BindingScope == GOFF::ESD_BSC_Section)
+      setBindingScope(Symbol.BindingScope);
+  } break;
+  case GOFF::ESD_ST_ElementDefinition: {
+    SymbolFlags.set(3, 1, Symbol.isRemovable()); // Removable
+    if (Symbol.isExecutable()) {
+      setExecutable(GOFF::ESD_EXE_CODE);
+      setReadOnly(true);
+    } else {
+      if (Symbol.isExecUnspecified())
+        setExecutable(GOFF::ESD_EXE_Unspecified);
+      else
+        setExecutable(GOFF::ESD_EXE_DATA);
+
+      if (Symbol.isForceRent() || Symbol.isReadOnly()) // TODO
+        setReadOnly(true);
+    }
+    Offset = 0; // TODO ED and SD are 1-1 for now
+    setAlignment(Symbol.Alignment);
+    SymbolFlags.set(0, 1, 1); // Fill-Byte Value Presence Flag
+    FillByteValue = 0;
+    SymbolFlags.set(1, 1, 0); // Mangled Flag TODO ?
+    setAmode(Symbol.Amode);
+    setRmode(Symbol.Rmode);
+    setTextStyle(Symbol.TextStyle);
+    setBindingAlgorithm(Symbol.BindAlgorithm);
+    setLoadingBehavior(Symbol.LoadBehavior);
+    SymbolFlags.set(5, 3, GOFF::ESD_RQ_0); // Reserved Qwords
+    if (Symbol.isForceRent())
+      setReadOnly(true);
+    NameSpaceId = Symbol.NameSpace;
+    Length = Symbol.SectionLength;
+    break;
+  }
+  case GOFF::ESD_ST_LabelDefinition: {
+    if (Symbol.isExecutable())
+      setExecutable(GOFF::ESD_EXE_CODE);
+    else
+      setExecutable(GOFF::ESD_EXE_DATA);
+    setBindingStrength(Symbol.BindingStrength);
+    setLinkageType(Symbol.Linkage);
+    SymbolFlags.set(2, 1, Symbol.Renamable); // Renamable;
+    setAmode(Symbol.Amode);
+    NameSpaceId = Symbol.NameSpace;
+    setBindingScope(Symbol.BindingScope);
+    AdaEsdId = Symbol.ADAEsdId;
+
+    // Only symbol that doesn't have an MC is the SectionLabelSymbol which
+    // implicitly has 0 offset into the parent SD!
+    if (auto *MCSym = Symbol.MCSym) {
+      uint64_t Ofs = Layout.getSymbolOffset(*MCSym);
+      // We only have signed 32bits of offset!
+      assert(Ofs < (((uint64_t)1) << 31) && "ESD offset out of range.");
+      Offset = static_cast<uint32_t>(Ofs);
+    }
+    break;
+  }
+  case GOFF::ESD_ST_ExternalReference: {
+    setExecutable(Symbol.isExecutable() ? GOFF::ESD_EXE_CODE : GOFF::ESD_EXE_DATA);
+    setBindingStrength(Symbol.BindingStrength);
+    setLinkageType(Symbol.Linkage);
+    SymbolFlags.set(2, 1, Symbol.Renamable); // Renamable;
+    setIndirectReference(Symbol.Indirect);
+    Offset = 0; // ERs don't do offsets
+    NameSpaceId = Symbol.NameSpace;
+    SymbolFlags.set(5, 3, GOFF::ESD_ES_None); // TODO What is this for..?
+    setBindingScope(Symbol.BindingScope);
+    setAmode(Symbol.Amode);
+    break;
+  }
+  case GOFF::ESD_ST_PartReference: {
+    setExecutable(Symbol.isExecutable() ? GOFF::ESD_EXE_CODE : GOFF::ESD_EXE_DATA);
+    NameSpaceId = Symbol.NameSpace;
+    setAlignment(Symbol.Alignment);
+    setAmode(Symbol.Amode);
+    setLinkageType(Symbol.Linkage);
+    setBindingScope(Symbol.BindingScope);
+    SymbolFlags.set(2, 1, Symbol.Renamable); // Renamable;
+    setDuplicateSeverity(Symbol.isWeakRef() ? GOFF::ESD_DSS_NoWarning : GOFF::ESD_DSS_Warning);
+    setIndirectReference(Symbol.Indirect);
+    setReadOnly(Symbol.ReadOnly);
+    SortPriority = Symbol.SortKey;
+
+    Length = Symbol.SectionLength;
+    break;
+  }
+  } // End switch
+
+  SmallString<256> Res;
+  ConverterEBCDIC::convertToEBCDIC(Symbol.Name, Res);
+  StringRef Name = Res.str();
+
+  // Assert here since this number is technically signed but we need uint for
+  // writing to records.
+  assert(Name.size() < GOFF::MaxDataLength &&
+         "Symbol max name length exceeded");
+  uint16_t NameLength = Name.size();
+
+  OS.newRecord(GOFF::RT_ESD, 69 + NameLength);
+  OS.writeBE<uint8_t>(Symbol.SymbolType);       // Symbol Type
+  OS.writeBE<uint32_t>(Symbol.EsdId);           // ESDID
+  OS.writeBE<uint32_t>(Symbol.ParentEsdId);     // Parent or Owning ESDID
+  OS.writeBE<uint32_t>(0);                      // Reserved
+  OS.writeBE<uint32_t>(Offset);                 // Offset or Address
+  OS.writeBE<uint32_t>(0);                      // Reserved
+  OS.writeBE<uint32_t>(Length);                 // Length
+  OS.writeBE<uint32_t>(Symbol.EASectionEsdId);  // Extended Attribute ESDID
+  OS.writeBE<uint32_t>(Symbol.EASectionOffset); // Extended Attribute Offset
+  OS.writeBE<uint32_t>(0);                      // Reserved
+  OS.writeBE<uint8_t>(NameSpaceId);             // Name Space ID
+  OS.writeBE<uint8_t>(SymbolFlags);             // Flags
+  OS.writeBE<uint8_t>(FillByteValue);           // Fill-Byte Value
+  OS.writeBE<uint8_t>(0);                       // Reserved
+  OS.writeBE<uint32_t>(AdaEsdId);               // ADA ESDID
+  OS.writeBE<uint32_t>(SortPriority);           // Sort Priority
+  OS.writeBE<uint64_t>(0);                      // Reserved
+  for (auto F : BehavAttrs)
+    OS.writeBE<uint8_t>(F);          // Behavioral Attributes
+  OS.writeBE<uint16_t>(NameLength);  // Name Length
+  OS.write(Name.data(), NameLength); // Name
+}
+
+namespace {
+/// Adapter stream to write a text section.
+class TextStream : public raw_ostream {
+  /// The underlying GOFFOstream.
+  GOFFOstream &OS;
+
+  /// The buffer size is the maximum number of bytes in a TXT section.
+  static constexpr size_t BufferSize = GOFF::MaxDataLength;
+
+  /// Static allocated buffer for the stream, used by the raw_ostream class. The
+  /// buffer is sized to hold the payload of a logical TXT record.
+  char Buffer[BufferSize];
+
+  /// The offset for the next TXT record. This is equal to the number of bytes
+  /// written.
+  size_t Offset;
+
+  /// The Esdid of the GOFF section.
+  const uint32_t EsdId;
+
+  /// The record style.
+  const GOFF::TXTRecordStyle RecordStyle;
+
+  /// See raw_ostream::write_impl.
+  void write_impl(const char *Ptr, size_t Size) override;
+
+  uint64_t current_pos() const override { return Offset; }
+
+public:
+  explicit TextStream(GOFFOstream &OS, uint32_t EsdId,
+                      GOFF::TXTRecordStyle RecordStyle)
+      : OS(OS), Offset(0), EsdId(EsdId),
+        RecordStyle(RecordStyle) {
+    SetBuffer(Buffer, sizeof(Buffer));
+  }
+
+  ~TextStream() { flush(); }
+};
+
+void TextStream::write_impl(const char *Ptr, size_t Size) {
+  size_t WrittenLength = 0;
+
+  // We only have signed 32bits of offset.
+  if (Offset + Size > std::numeric_limits<int32_t>::max())
+    report_fatal_error("TXT section too large");
+
+  while (WrittenLength < Size) {
+    size_t ToWriteLength =
+        std::min(Size - WrittenLength, size_t(GOFF::MaxDataLength));
+
+    OS.newRecord(GOFF::RT_TXT, 21 + ToWriteLength);
+    OS.writeBE<uint8_t>(Flags(4, 4, RecordStyle));     // Text Record Style
+    OS.writeBE<uint32_t>(EsdId);                         // Element ESDID
+    OS.writeBE<uint32_t>(0);                             // Reserved
+    OS.writeBE<uint32_t>(static_cast<uint32_t>(Offset)); // Offset
+    OS.writeBE<uint32_t>(0);                     // Text Field True Length
+    OS.writeBE<uint16_t>(0);                     // Text Encoding
+    OS.writeBE<uint16_t>(ToWriteLength);         // Data Length
+    OS.write(Ptr + WrittenLength, ToWriteLength); // Data
+
+    WrittenLength += ToWriteLength;
+    Offset += ToWriteLength;
+  }
+}
+} // namespace
+
+void GOFFObjectWriter::writeText(const GOFFSection &Section, const MCAssembler &Asm,
+                                 const MCAsmLayout &Layout) {
+  // TODO: This assumes the ED. Is that correct?  Probably not.
+  TextStream S(OS, Section.Pptr->EsdId,
+               Section.IsStructured ? GOFF::TXT_RS_Structured
+                                    : GOFF::TXT_RS_Byte);
+  Asm.writeSectionData(S, Section.MCSec, Layout);
+}
+
 void GOFFObjectWriter::writeEnd() {
   uint8_t F = GOFF::END_EPR_None;
   uint8_t AMODE = 0;
   uint32_t ESDID = 0;
 
   // TODO Set Flags/AMODE/ESDID for entry point.
 
   OS.newRecord(GOFF::RT_END, /*Size=*/13);
   OS.writeBE<uint8_t>(Flags(6, 2, F)); // Indicator flags
   OS.writeBE<uint8_t>(AMODE);          // AMODE
   OS.write_zeros(3);                   // Reserved
   // The record count is the number of logical records. In principle, this value
   // is available as OS.logicalRecords(). However, some tools rely on this field
   // being zero.
   OS.writeBE<uint32_t>(0);     // Record Count
   OS.writeBE<uint32_t>(ESDID); // ESDID (of entry point)
   OS.finalize();
 }
 
 uint64_t GOFFObjectWriter::writeObject(MCAssembler &Asm,
                                        const MCAsmLayout &Layout) {
   uint64_t StartOffset = OS.tell();
 
   writeHeader();
+  for (const auto &Sym : EsdSymbols)
+    writeSymbol(*Sym, Layout);
+  for (const auto &Sec : Sections)
+    writeText(*Sec, Asm, Layout);
   writeEnd();
 
-  LLVM_DEBUG(dbgs() << "Wrote " << OS.logicalRecords() << " logical records.");
-
   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/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/MCAsmInfo.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCSectionGOFF.h"
+#include "llvm/MC/MCSymbol.h"
+#include "llvm/MC/MCSymbolGOFF.h"
 #include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/Casting.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;
 }
+
+void MCGOFFStreamer::initSections(bool NoExecStack,
+                                  const MCSubtargetInfo &STI) {
+  MCContext &Ctx = getContext();
+  switchSection(Ctx.getObjectFileInfo()->getTextSection());
+
+  if (NoExecStack)
+    switchSection(Ctx.getAsmInfo()->getNonexecutableStackSection(Ctx));
+}
+
+void MCGOFFStreamer::switchSection(MCSection *S, const MCExpr *Subsection) {
+  auto Section = cast<MCSectionGOFF>(S);
+  MCSection *Parent = Section->getParent();
+
+  if (Parent) {
+    const MCExpr *Subsection = Section->getSubsectionId();
+    assert(Subsection && "No subsection associated with child section");
+    this->MCObjectStreamer::switchSection(Parent, Subsection);
+    return;
+  }
+
+  this->MCObjectStreamer::switchSection(Section, Subsection);
+}
+
+bool MCGOFFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
+  auto *Symbol = cast<MCSymbolGOFF>(S);
+
+  getAssembler().registerSymbol(*Symbol);
+
+  switch (Attribute) {
+  case MCSA_Global:
+    Symbol->setExternal(true);
+    break;
+  case MCSA_Local:
+    Symbol->setExternal(false);
+    break;
+  case MCSA_Hidden:
+    Symbol->setHidden(true);
+    break;
+  default:
+    return false;
+  }
+  return true;
+}

llvm/lib/Target/SystemZ/SystemZAsmPrinter.h

bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
                              const char *ExtraCode, raw_ostream &OS) override;
 
   bool doInitialization(Module &M) override {
     SM.reset();
     return AsmPrinter::doInitialization(M);
   }
   void emitFunctionEntryLabel() override;
   void emitFunctionBodyEnd() override;
+  void emitGlobalVariable(const GlobalVariable *GV) override;
+  const MCExpr *lowerConstant(const Constant *CV) override;
 
 private:
   void emitCallInformation(CallType CT);
   void LowerFENTRY_CALL(const MachineInstr &MI, SystemZMCInstLower &MCIL);
   void LowerSTACKMAP(const MachineInstr &MI);
   void LowerPATCHPOINT(const MachineInstr &MI, SystemZMCInstLower &Lower);
   void emitAttributes(Module &M);
 };
 } // end namespace llvm
 
 #endif

llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp

 #include "SystemZAsmPrinter.h"
 #include "MCTargetDesc/SystemZInstPrinter.h"
 #include "MCTargetDesc/SystemZMCExpr.h"
 #include "SystemZConstantPoolValue.h"
 #include "SystemZMCInstLower.h"
 #include "TargetInfo/SystemZTargetInfo.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/BinaryFormat/GOFF.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbolGOFF.h"
 #include "llvm/MC/TargetRegistry.h"
 
 using namespace llvm;
 
 // Return an RI instruction like MI with opcode Opcode, but with the
 // GR64 register operands turned into GR32s.
 static MCInst lowerRILow(const MachineInstr *MI, unsigned Opcode) {
   if (MI->isCompare())
if (TargetHasVector && SavedVRMask) {
     OutStreamer->emitInt32(FrameAndVROffset);
   }
 
   // Emit offset to entry point optional section (0x80 of flags 4).
   OutStreamer->emitAbsoluteSymbolDiff(CurrentFnEPMarkerSym, CurrentFnPPA1Sym,
                                       4);
 }
 
+void SystemZAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
+  if (TM.getTargetTriple().isOSzOS()) {
+    auto *Sym = cast<MCSymbolGOFF>(getSymbol(GV));
+    Sym->setExecutable(GOFF::ESD_EXE_DATA);
+  }
+
+  return AsmPrinter::emitGlobalVariable(GV);
+}
+
+const MCExpr *SystemZAsmPrinter::lowerConstant(const Constant *CV) {
+  const Triple &TargetTriple = TM.getTargetTriple();
+  if (TargetTriple.isOSzOS()) {
+    const GlobalAlias *GA = dyn_cast<GlobalAlias>(CV);
+    const GlobalVariable *GV = dyn_cast<GlobalVariable>(CV);
+    const Function *FV = dyn_cast<Function>(CV);
+    bool IsFunc = !GV && (FV || (GA && isa<Function>(GA->getAliaseeObject())));
+    MCSymbolGOFF *Sym = NULL;
+
+    if (GA)
+      Sym = cast<MCSymbolGOFF>(getSymbol(GA));
+    else if (IsFunc)
+      Sym = cast<MCSymbolGOFF>(getSymbol(FV));
+    else if (GV)
+      Sym = cast<MCSymbolGOFF>(getSymbol(GV));
+
+    if (IsFunc) {
+    } else if (Sym) {
+      Sym->setExecutable(GOFF::ESD_EXE_DATA);
+      return MCSymbolRefExpr::create(Sym, OutContext);
+    }
+  }
+
+  return AsmPrinter::lowerConstant(CV);
+}
+
 void SystemZAsmPrinter::emitFunctionEntryLabel() {
   const SystemZSubtarget &Subtarget = MF->getSubtarget<SystemZSubtarget>();
 
   if (Subtarget.getTargetTriple().isOSzOS()) {
     MCContext &OutContext = OutStreamer->getContext();
 
     // Save information for later use.
     std::string N(MF->getFunction().hasName()

llvm/test/MC/GOFF/basic-goff-64.ll

+; RUN: llc %s -mtriple s390x-ibm-zos -filetype=obj -o - | od -v -An -tx1 | FileCheck --ignore-case %s
+
+@x = global i32 0, align 4
+@y = internal global i32 1, align 4
+@z = external global i32, align 4
+
+; Function Attrs: noinline nounwind optnone
+define hidden void @foo() {
+entry:
+  store i32 8200, ptr @x, align 4
+  %0 = load i32, ptr @x, align 4
+  store i32 2, ptr @y, align 4
+  store i32 100, ptr @z, align 4
+  call void @bar(i32 noundef signext %0)
+  ret void
+}
+
+declare void @bar(i32 noundef signext)
+
+; HDR Record
+; CHECK: 03 f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+
+; Records for basic-goff-64#C
+; Requires a continuation record due to the name's length. ESD items
+; with names of length greater than 8 require continuation records.
+; Byte 1 of the first record for this ESD entry is 0x01 to indicate
+; that this record is continued, and byte 2 of the second record
+; to indicate that this is the final continuation record.
+; Byte 3 of first record for this ESD entry is 0x00 to indicate
+; SD (Section Definition).
+; CHECK: 03 01 00 00 00 00 00 01 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 60
+; CHECK: 00 01 00 00 00 00 00 0f 82 81 a2 89 83 60 87 96
+; CHECK: 03 02 00 86 86 60 f6 f4 7b c3 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+
+; Record for C_WSA64.
+; Byte 3 is 0x01 to indicate ED (Element Definition).
+; This represents the writable static area.
+; CHECK: 03 00 00 01 00 00 00 02 00 00 00 01 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 03 80 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 04 01 01
+; CHECK: 00 40 04 00 00 00 00 07 c3 6d e6 e2 c1 f6 f4 00
+
+; Records for basic-goff-64#S
+; Requires a continuation record.
+; Byte 3 is 0x03 to indicate PR (Part Reference).
+; CHECK: 03 01 00 03 00 00 00 03 00 00 00 02 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 01
+; CHECK: 10 01 24 00 00 00 00 0f 82 81 a2 89 83 60 87 96
+; CHECK: 03 02 00 86 86 60 f6 f4 7b e2 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+
+; Record for C_CODE64.
+; Byte 3 is 0x01 to indicate SD (Element Definition).
+; CHECK: 03 00 00 01 00 00 00 04 00 00 00 01 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 26 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 01 80 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 04 00 0a
+; CHECK: 00 00 03 00 00 00 00 08 c3 6d c3 d6 c4 c5 f6 f4
+
+; Records for basic-goff-64#C. Note that names for ESD entries
+; need not be unique.
+; Byte 3 is 0x02 to indicate LD (Label Definition).
+; CHECK: 03 01 00 02 00 00 00 05 00 00 00 04 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 02
+; CHECK: 00 01 20 00 00 00 00 0f 82 81 a2 89 83 60 87 96
+; CHECK: 03 02 00 86 86 60 f6 f4 7b c3 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+
+; Record for Section Definition for global variable x.
+; Note that all initialized global variables require their
+; own section definition. This includes functions defined in
+; this module. Note that bytes 4-7 indicate that ESDID is 6.
+; Byte 3 is 0x00 to indicate SD.
+; CHECK: 03 00 00 00 00 00 00 06 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 01 a7 00 00 00 00 00 00 00
+
+; Record for C_WSA64 belonging to Section for global variable x.
+; Byte 3 is 0x01 to indicate ED.
+; Bytes 8-11 indicate that Parent ESDID is 6.
+; CHECK: 03 00 00 01 00 00 00 07 00 00 00 06 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 03 80 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 04 01 01
+; CHECK: 00 40 04 00 00 00 00 07 c3 6d e6 e2 c1 f6 f4 00
+
+; Record for PR of global variable x.
+; Byte 3 is 0x03 to indicate PR.
+; Bytes 8-11 indicate that Parent ESDID is 7, the above
+; C_WSA64.
+; Byte 65 is 0x04 = 0b00000100. Bits 4-7 indicate the
+; binding scope, which is Import-Export scope. This means 
+; that symbol is available for dynamic binding.
+; CHECK: 03 00 00 03 00 00 00 08 00 00 00 07 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 01
+; CHECK: 10 04 20 00 00 00 00 01 a7 00 00 00 00 00 00 00
+
+; Record for function foo().
+; Byte 3 is 0x02 to indicate LD.
+; This record is owned by ESD entry with ID 4, which is 
+; C_CODE64. That is in turn owned by ESD entry with ID 1,
+; which is C_WSA64, which is owned by Section Definition
+; basic-goff-64#C. All functions in GOFF defined in the
+; compilation unit are defined in this manner.
+; Byte 63 is 0x02 = 0b00000010. Bits 5-7 indicate that
+; this record is executable, since it contains code. Note
+; that Bits 5-7 should be 001 if it is not executable and
+; 000 if executability is not specified.
+; Byte 65 is 0x03 = 0b00000011. Bits 4-7 indicate the
+; binding scope, which is library scope. This means 
+; that symbol is NOT available fo dynamic binding. However,
+; it is still available for static linking. This is due to the
+; hidden attribute on the function definition.
+; CHECK: 03 00 00 02 00 00 00 09 00 00 00 04 00 00 00 00
+; CHECK: 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 02
+; CHECK: 00 03 20 00 00 00 00 03 86 96 96 00 00 00 00 00
+
+; Record for internal global variable y. This global variable
+; is explicitly listed as internal to this compilation unit.
+; It has the same ownership as the above record, however its binding
+; scope is Section Scope. This means that this variable is only 
+; visible to functions in the same section (ie. not visible to any
+; function in any other compilation unit). 
+; Byte 65 is 0x01 = 0b00000001. Bits 4-7 indicate the
+; binding scope, which is section scope.
+; CHECK: 03 00 00 02 00 00 00 0a 00 00 00 04 00 00 00 00
+; CHECK: 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 01
+; CHECK: 00 01 20 00 00 00 00 01 a8 00 00 00 00 00 00 00
+
+; Record for C_WSA64. Part of section basic-goff-64#C
+; and contains externally defined global variables.
+; CHECK: 03 00 00 01 00 00 00 0b 00 00 00 01 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 03 80 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 04 01 01
+; CHECK: 00 40 00 00 00 00 00 07 c3 6d e6 e2 c1 f6 f4 00
+
+; Record for external global variable z. This is NOT
+; initialized in this compilation unit and so unlike
+; global variable x, it lacks its own section definition.
+; Byte 3 is 0x03 to indicate PR.
+; Bytes 8-11 indicate that parent ESDID is 0b, which is
+; above C_WSA64.
+; CHECK: 03 00 00 03 00 00 00 0c 00 00 00 0b 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 01
+; CHECK: 10 04 20 00 00 00 00 01 a9 00 00 00 00 00 00 00
+
+; Record for externally defined function bar().
+; Byte 3 is 0x04 to indicate External Reference (ErWx).
+; Bytes 8-11 indicate that parent ESDID is 01, the section
+; definition for this module. (basic-goff-64#C). 
+; Byte 64 indicates that the binding scope is Import-Export
+; Scope, since the definition may be something we dynamically
+; link against.
+; CHECK: 03 00 00 04 00 00 00 0d 00 00 00 01 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 01
+; CHECK: 00 04 20 00 00 00 00 03 82 81 99 00 00 00 00 00
+
+; TXT Records
+; One TXT Record corresponding to the C_CODE64 Section.
+; This contains the bodies of the function(s) that make up
+; a module. Bytes 0-23 contain metadata, bytes 24 and onwards
+; contain data so we don't check those.
+; Byte 2 is 0x10 = 0b00010000. Byte 2, bits 0-3 indicate the
+; record type. 0b0001 indicates a TXT Record.
+; Bytes 4-7 indicate that the owning ESD has ID 4. This is
+; C_CODE64. Note that the parent ESD record must be an ED or
+; PR Record.
+; Bytes 22-23 contain the data length.
+; CHECK: 03 10 00 00 00 00 00 04 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 26
+
+; TXT Record corresponding to global variable x. This belongs
+; to the PR of x.
+; Bytes 4-7 indicate that the owning ESD has ID 8. This is the
+; PR for global variable x.
+; Byte 22-23 contain the data length, which is 4, as expected for
+; an integer.
+; CHECK: 03 10 00 00 00 00 00 08 00 00 00 00 00 00 00 00
+; CHECK: 00 00 00 00 00 00 00 04