[SystemZ][z/OS] Initial code to generate assembly files on z/OS

[anirudhp]

Summary

• This patch consists of the bare basic code needed in order to generate some assembly for the z/OS target.
• Only the .text and the .bss sections are added for now.
• The relevant MCSectionGOFF/Symbol interfaces have been added. This enables us to print out the GOFF machine code sections.
• This patch enables us to add simple lit tests wherever possible, and contribute to the testing coverage for the z/OS target
• Further improvements and additions will be made in future patches.

[tmatheson]

Looks good in general, just a few suggestions. The commit message/description should say specifically what functionality this adds.

llvm/include/llvm/MC/MCContext.h

281

I don't think this type is necessary, you could use StringRef directly in the map.

llvm/include/llvm/MC/MCSectionGOFF.h

33

Is this necessary?

38

It might be a good idea to generalise printName from MCSectionELF.cpp to handle outputting names in quotes with proper escaping.

llvm/lib/MC/MCContext.cpp

621–633

Something like this should do the same, assuming the key is changed to StringRef

llvm/test/CodeGen/SystemZ/zos-simple-test.ll

4

The test doesn't seem directly related to the GOFF section code added here. e.g. it doesn't check any section output, but does check an instruction not added in this patch.

[anirudhp]

• Addressing comments

llvm/include/llvm/MC/MCContext.h

281

Hmm you are correct, since there is only field in the key. But taking into account future maintainability, to me, this seems better to leave in as is.

llvm/include/llvm/MC/MCSectionGOFF.h

33

Nope. You're right. There doesn't seem to be a reason for having a virtual destructor here. The default destructor is enough.

38

Sure. Done.

llvm/test/CodeGen/SystemZ/zos-simple-test.ll

4

I have added a uninitialized global variable to grep for the .bss section and added a new check string(s) to check for both of them.

[anirudhp]

llvm/test/CodeGen/SystemZ/zos-simple-test.ll

4

In regards to the instruction check, the instruction already exists (we're using existing SystemZ instructions), if the check itself makes it confusing I can remove it.

[anirudhp]

llvm/include/llvm/MC/MCSectionGOFF.h

38

Sorry I just realized I didn't quite answer your question properly. Yes, I will port over the complete printName implementation from the ELF part over.

However, when looking at it, I realized there;s a bug with this patch. The GOFF sections are printed, but the ELF section are printed too, and this doesn't quite make sense. There shouldn't be mixing of sections. So I will try to resolve that first.

[anirudhp]

• Introduced GOFF support in the TargetLoweringObjectImpl phase, so that we correctly deduce the sections to print out, and not fall back on the default ELF sections.
• This was what was happening previously, with a mix of both GOFF sections and ELF sections.

[tmatheson]

llvm/include/llvm/MC/MCSectionGOFF.h

38

The only change I can see from the first revision is that instead of OS << getName() it is now printing each character individually? This will be slower and more verbose than the original.

The printName function in MCSectionELF.cpp is iterating over individual characters in the name so that it can correctly quote them, e.g. if the name is xx"yy it will be printed as "xx\"yy". Since this is a common operation (it's already copy-pasted verbatim to MCSectionWasm.cpp) it seems sensible to move it somewhere commonly accessible and call it from all three MCSectionXXX.cpp.

If you think doing that is outside the scope of this work then please restore the original version.

llvm/lib/MC/MCContext.cpp

621–633

This comment still applies (even without getting rid of GOFFSectionKey)

[anirudhp]

• For the GOFFUniquingMap map, replace the key from a struct to a standard std::string as the Key. This should eliminate the need for the struct and condenses the getGOFFSection function a bit more

[anirudhp]

llvm/include/llvm/MC/MCSectionGOFF.h

38

Ahh I see what you mean. I think for now, I'd rather just keep it the way it was originally (i.e. not looping through it character by character). I would possibly keep the refactoring of the printName function so that it can be used by MCSection[ELF|GOFF|Wasm] as a separate patch if that's okay?

llvm/lib/MC/MCContext.cpp

621–633

Looking at it further. I followed your previous comment and removed the GOFFSectionKey struct and used as a standard std::string as the Key. We do have code that we plan to put up in the next series of patches, which would make a StringRef as the key not work, hence I opted for a standard std::string.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

public:
   /// For functions, this will always return a function descriptor symbol.
   MCSymbol *getTargetSymbol(const GlobalValue *GV,
                             const TargetMachine &TM) const override;
 
   MCSymbol *getFunctionEntryPointSymbol(const GlobalValue *Func,
                                         const TargetMachine &TM) const override;
 };
 
+class TargetLoweringObjectFileGOFF : public TargetLoweringObjectFile {
+public:
+  TargetLoweringObjectFileGOFF();
+  ~TargetLoweringObjectFileGOFF() override = default;
+
+  MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
+                                    const TargetMachine &TM) const override;
+  MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
+                                      const TargetMachine &TM) const override;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H

llvm/include/llvm/MC/MCContext.h

namespace llvm {
   class CodeViewContext;
   class MCAsmInfo;
   class MCLabel;
   class MCObjectFileInfo;
   class MCRegisterInfo;
   class MCSection;
   class MCSectionCOFF;
   class MCSectionELF;
+  class MCSectionGOFF;
   class MCSectionMachO;
   class MCSectionWasm;
   class MCSectionXCOFF;
   class MCStreamer;
   class MCSymbol;
   class MCSymbolELF;
   class MCSymbolWasm;
   class MCSymbolXCOFF;
   class MDNode;
   class SMDiagnostic;
   class SMLoc;
   class SourceMgr;
 
   /// Context object for machine code objects.  This class owns all of the
   /// sections that it creates.
   ///
   class MCContext {
   public:
     using SymbolTable = StringMap<MCSymbol *, BumpPtrAllocator &>;
     using DiagHandlerTy =
         std::function<void(const SMDiagnostic &, bool, const SourceMgr &,
                            std::vector<const MDNode *> &)>;
-    enum Environment { IsMachO, IsELF, IsCOFF, IsWasm, IsXCOFF };
+    enum Environment { IsMachO, IsELF, IsGOFF, IsCOFF, IsWasm, IsXCOFF };
 
   private:
     Environment Env;
 
     /// The triple for this object.
     Triple TT;
 
     /// The SourceMgr for this object, if any.
private:
     ///
     /// We use a bump pointer allocator to avoid the need to track all allocated
     /// objects.
     BumpPtrAllocator Allocator;
 
     SpecificBumpPtrAllocator<MCSectionCOFF> COFFAllocator;
     SpecificBumpPtrAllocator<MCSectionELF> ELFAllocator;
     SpecificBumpPtrAllocator<MCSectionMachO> MachOAllocator;
+    SpecificBumpPtrAllocator<MCSectionGOFF> GOFFAllocator;
     SpecificBumpPtrAllocator<MCSectionWasm> WasmAllocator;
     SpecificBumpPtrAllocator<MCSectionXCOFF> XCOFFAllocator;
     SpecificBumpPtrAllocator<MCInst> MCInstAllocator;
 
     /// Bindings of names to symbols.
     SymbolTable Symbols;
 
     /// A mapping from a local label number and an instance count to a symbol.
private:
     struct WasmSectionKey {
       std::string SectionName;
       StringRef GroupName;
       unsigned UniqueID;
 
       WasmSectionKey(StringRef SectionName, StringRef GroupName,
                      unsigned UniqueID)
           : SectionName(SectionName), GroupName(GroupName), UniqueID(UniqueID) {
       }
 
       bool operator<(const WasmSectionKey &Other) const {
         if (SectionName != Other.SectionName)
           return SectionName < Other.SectionName;
         if (GroupName != Other.GroupName)
           return GroupName < Other.GroupName;
         return UniqueID < Other.UniqueID;
       }
struct XCOFFSectionKey {
         return std::tie(SectionName, DwarfSubtypeFlags) <
                std::tie(Other.SectionName, Other.DwarfSubtypeFlags);
       }
     };
 
     StringMap<MCSectionMachO *> MachOUniquingMap;
     std::map<ELFSectionKey, MCSectionELF *> ELFUniquingMap;
     std::map<COFFSectionKey, MCSectionCOFF *> COFFUniquingMap;
+    std::map<std::string, MCSectionGOFF *> GOFFUniquingMap;
     std::map<WasmSectionKey, MCSectionWasm *> WasmUniquingMap;
     std::map<XCOFFSectionKey, MCSectionXCOFF *> XCOFFUniquingMap;
     StringMap<bool> RelSecNames;
 
     SpecificBumpPtrAllocator<MCSubtargetInfo> MCSubtargetAllocator;
 
     /// Do automatic reset in destructor
     bool AutoReset;
public:
     bool isELFGenericMergeableSection(StringRef Name);
 
     /// Return the unique ID of the section with the given name, flags and entry
     /// size, if it exists.
     Optional<unsigned> getELFUniqueIDForEntsize(StringRef SectionName,
                                                 unsigned Flags,
                                                 unsigned EntrySize);
 
+    MCSectionGOFF *getGOFFSection(StringRef Section, SectionKind Kind);
+
     MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                   SectionKind Kind, StringRef COMDATSymName,
                                   int Selection,
                                   unsigned UniqueID = GenericSectionID,
                                   const char *BeginSymName = nullptr);
 
     MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                   SectionKind Kind,

llvm/include/llvm/MC/MCObjectFileInfo.h

 
 private:
   bool PositionIndependent = false;
   MCContext *Ctx = nullptr;
   VersionTuple SDKVersion;
 
   void initMachOMCObjectFileInfo(const Triple &T);
   void initELFMCObjectFileInfo(const Triple &T, bool Large);
+  void initGOFFMCObjectFileInfo(const Triple &T);
   void initCOFFMCObjectFileInfo(const Triple &T);
   void initWasmMCObjectFileInfo(const Triple &T);
   void initXCOFFMCObjectFileInfo(const Triple &T);
   MCSection *getDwarfComdatSection(const char *Name, uint64_t Hash) const;
 
 public:
   void setSDKVersion(const VersionTuple &TheSDKVersion) {
     SDKVersion = TheSDKVersion;
   }
 
   const VersionTuple &getSDKVersion() const { return SDKVersion; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/MC/MCSection.h

 };
 
 /// Instances of this class represent a uniqued identifier for a section in the
 /// current translation unit.  The MCContext class uniques and creates these.
 class MCSection {
 public:
   static constexpr unsigned NonUniqueID = ~0U;
 
-  enum SectionVariant { SV_COFF = 0, SV_ELF, SV_MachO, SV_Wasm, SV_XCOFF };
+  enum SectionVariant {
+    SV_COFF = 0,
+    SV_ELF,
+    SV_GOFF,
+    SV_MachO,
+    SV_Wasm,
+    SV_XCOFF
+  };
 
   /// Express the state of bundle locked groups while emitting code.
   enum BundleLockStateType {
     NotBundleLocked,
     BundleLocked,
     BundleLockedAlignToEnd
   };
 

llvm/include/llvm/MC/MCSectionGOFF.h

+//===-- llvm/MC/MCSectionGOFF.h - GOFF Machine Code Sections ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares the MCSectionGOFF class, which contains all of the
+/// necessary machine code sections for the GOFF file format.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCSECTIONGOFF_H
+#define LLVM_MC_MCSECTIONGOFF_H
+
+#include "llvm/MC/MCSection.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+class MCExpr;
+
+class MCSectionGOFF final : public MCSection {
+private:
+  friend class MCContext;
+  MCSectionGOFF(StringRef Name, SectionKind K)
+      : MCSection(SV_GOFF, Name, K, nullptr) {}
+
+public:
+  void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
+                            raw_ostream &OS,
+                            const MCExpr *Subsection) const override {
+    OS << "\t.section\t\"" << getName() << "\"\n";
+  }
+
+  bool UseCodeAlign() const override { return false; }
+
+  bool isVirtualSection() const override { return false; }
+
+  static bool classof(const MCSection *S) { return S->getVariant() == SV_GOFF; }
+};
+} // end namespace llvm
+
+#endif

llvm/include/llvm/MC/MCSymbol.h

 class MCSymbol {
 protected:
   /// The kind of the symbol.  If it is any value other than unset then this
   /// class is actually one of the appropriate subclasses of MCSymbol.
   enum SymbolKind {
     SymbolKindUnset,
     SymbolKindCOFF,
     SymbolKindELF,
+    SymbolKindGOFF,
     SymbolKindMachO,
     SymbolKindWasm,
     SymbolKindXCOFF,
   };
 
   /// A symbol can contain an Offset, or Value, or be Common, but never more
   /// than one of these.
   enum Contents : uint8_t {
public:
 
   /// Mark the symbol as undefined.
   void setUndefined() { FragmentAndHasName.setPointer(nullptr); }
 
   bool isELF() const { return Kind == SymbolKindELF; }
 
   bool isCOFF() const { return Kind == SymbolKindCOFF; }
 
+  bool isGOFF() const { return Kind == SymbolKindGOFF; }
+
   bool isMachO() const { return Kind == SymbolKindMachO; }
 
   bool isWasm() const { return Kind == SymbolKindWasm; }
 
   bool isXCOFF() const { return Kind == SymbolKindXCOFF; }
 
   /// @}
   /// \name Variable Symbols

llvm/include/llvm/MC/MCSymbolGOFF.h

+//===-- llvm/MC/MCSymbolGOFF.h - GOFF Machine Code Symbols ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the MCSymbolGOFF class
+///
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_MC_MCSYMBOLGOFF_H
+#define LLVM_MC_MCSYMBOLGOFF_H
+
+#include "llvm/MC/MCSymbol.h"
+
+namespace llvm {
+
+class MCSymbolGOFF : public MCSymbol {
+public:
+  MCSymbolGOFF(const StringMapEntry<bool> *Name, bool IsTemporary)
+      : MCSymbol(SymbolKindGOFF, Name, IsTemporary) {}
+  static bool classof(const MCSymbol *S) { return S->isGOFF(); }
+};
+} // end namespace llvm
+
+#endif

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/PseudoProbe.h"
 #include "llvm/IR/Type.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
+#include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/SectionKind.h"
MCSection *TargetLoweringObjectFileXCOFF::getSectionForTOCEntry(
   // Use TE storage-mapping class when large code model is enabled so that
   // the chance of needing -bbigtoc is decreased.
   return getContext().getXCOFFSection(
       cast<MCSymbolXCOFF>(Sym)->getSymbolTableName(), SectionKind::getData(),
       XCOFF::CsectProperties(
           TM.getCodeModel() == CodeModel::Large ? XCOFF::XMC_TE : XCOFF::XMC_TC,
           XCOFF::XTY_SD));
 }
+
+//===----------------------------------------------------------------------===//
+//                                  GOFF
+//===----------------------------------------------------------------------===//
+TargetLoweringObjectFileGOFF::TargetLoweringObjectFileGOFF()
+    : TargetLoweringObjectFile() {}
+
+MCSection *TargetLoweringObjectFileGOFF::getExplicitSectionGlobal(
+    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
+  return SelectSectionForGlobal(GO, Kind, TM);
+}
+
+MCSection *TargetLoweringObjectFileGOFF::SelectSectionForGlobal(
+    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
+  auto *Symbol = TM.getSymbol(GO);
+  if (Kind.isBSS())
+    return getContext().getGOFFSection(Symbol->getName(),
+                                       SectionKind::getBSS());
+
+  return getContext().getObjectFileInfo()->getTextSection();
+}

llvm/lib/MC/MCContext.cpp

 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCLabel.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
+#include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolCOFF.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/MC/MCSymbolGOFF.h"
 #include "llvm/MC/MCSymbolMachO.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
case Triple::ELF:
     break;
   case Triple::Wasm:
     Env = IsWasm;
     break;
   case Triple::XCOFF:
     Env = IsXCOFF;
     break;
   case Triple::GOFF:
-    report_fatal_error("Cannot initialize MC for GOFF object file format");
+    Env = IsGOFF;
     break;
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot initialize MC for unknown object file format.");
     break;
   }
 }
 
 MCContext::~MCContext() {
void MCContext::reset() {
   SrcMgr = nullptr;
   InlineSrcMgr.reset();
   LocInfos.clear();
   DiagHandler = defaultDiagHandler;
 
   // Call the destructors so the fragments are freed
   COFFAllocator.DestroyAll();
   ELFAllocator.DestroyAll();
+  GOFFAllocator.DestroyAll();
   MachOAllocator.DestroyAll();
   XCOFFAllocator.DestroyAll();
   MCInstAllocator.DestroyAll();
 
   MCSubtargetAllocator.DestroyAll();
   InlineAsmUsedLabelNames.clear();
   UsedNames.clear();
   Symbols.clear();
   Allocator.Reset();
   Instances.clear();
   CompilationDir.clear();
   MainFileName.clear();
   MCDwarfLineTablesCUMap.clear();
   SectionsForRanges.clear();
   MCGenDwarfLabelEntries.clear();
   DwarfDebugFlags = StringRef();
   DwarfCompileUnitID = 0;
   CurrentDwarfLoc = MCDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0);
 
   CVContext.reset();
 
   MachOUniquingMap.clear();
   ELFUniquingMap.clear();
+  GOFFUniquingMap.clear();
   COFFUniquingMap.clear();
   WasmUniquingMap.clear();
   XCOFFUniquingMap.clear();
 
   ELFEntrySizeMap.clear();
   ELFSeenGenericMergeableSections.clear();
 
   NextID.clear();
MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
   static_assert(std::is_trivially_destructible<MCSymbolXCOFF>(),
                 "MCSymbol classes must be trivially destructible");
 
   switch (getObjectFileType()) {
   case MCContext::IsCOFF:
     return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
   case MCContext::IsELF:
     return new (Name, *this) MCSymbolELF(Name, IsTemporary);
+  case MCContext::IsGOFF:
+    return new (Name, *this) MCSymbolGOFF(Name, IsTemporary);
   case MCContext::IsMachO:
     return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
   case MCContext::IsWasm:
     return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
   case MCContext::IsXCOFF:
     return createXCOFFSymbolImpl(Name, IsTemporary);
   }
   return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,

 Optional<unsigned> MCContext::getELFUniqueIDForEntsize(StringRef SectionName,
                                                        unsigned Flags,
                                                        unsigned EntrySize) {
   auto I = ELFEntrySizeMap.find(
       MCContext::ELFEntrySizeKey{SectionName, Flags, EntrySize});
   return (I != ELFEntrySizeMap.end()) ? Optional<unsigned>(I->second) : None;
 }
 
+MCSectionGOFF *MCContext::getGOFFSection(StringRef Section, SectionKind Kind) {
+  // Do the lookup. If we don't have a hit, return a new section.
+  auto &GOFFSection = GOFFUniquingMap[Section.str()];
+  if (!GOFFSection)
+    GOFFSection = new (GOFFAllocator.Allocate()) MCSectionGOFF(Section, Kind);
+
+  return GOFFSection;
+}
+
 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
                                          unsigned Characteristics,
                                          SectionKind Kind,
                                          StringRef COMDATSymName, int Selection,
                                          unsigned UniqueID,
                                          const char *BeginSymName) {
   MCSymbol *COMDATSymbol = nullptr;
   if (!COMDATSymName.empty()) {
     COMDATSymbol = getOrCreateSymbol(COMDATSymName);
     COMDATSymName = COMDATSymbol->getName();
   }
 
 
   // Do the lookup, if we have a hit, return it.

llvm/lib/MC/MCObjectFileInfo.cpp

 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
+#include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 
 using namespace llvm;
 
 static bool useCompactUnwind(const Triple &T) {
   // Only on darwin.
void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T, bool Large) {
 
   StackSizesSection = Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, 0);
 
   PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0);
   PseudoProbeDescSection =
       Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0);
 }
 
+void MCObjectFileInfo::initGOFFMCObjectFileInfo(const Triple &T) {
+  TextSection = Ctx->getGOFFSection(".text", SectionKind::getText());
+  BSSSection = Ctx->getGOFFSection(".bss", SectionKind::getBSS());
+}
+
 void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
   EHFrameSection =
       Ctx->getCOFFSection(".eh_frame", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
                                            COFF::IMAGE_SCN_MEM_READ,
                           SectionKind::getData());
 
   // Set the `IMAGE_SCN_MEM_16BIT` flag when compiling for thumb mode.  This is
   // used to indicate to the linker that the text segment contains thumb instructions
case MCContext::IsMachO:
     initMachOMCObjectFileInfo(TheTriple);
     break;
   case MCContext::IsCOFF:
     initCOFFMCObjectFileInfo(TheTriple);
     break;
   case MCContext::IsELF:
     initELFMCObjectFileInfo(TheTriple, LargeCodeModel);
     break;
+  case MCContext::IsGOFF:
+    initGOFFMCObjectFileInfo(TheTriple);
+    break;
   case MCContext::IsWasm:
     initWasmMCObjectFileInfo(TheTriple);
     break;
   case MCContext::IsXCOFF:
     initXCOFFMCObjectFileInfo(TheTriple);
     break;
   }
 }

llvm/lib/MC/MCParser/AsmParser.cpp

case MCContext::IsCOFF:
     break;
   case MCContext::IsMachO:
     PlatformParser.reset(createDarwinAsmParser());
     IsDarwin = true;
     break;
   case MCContext::IsELF:
     PlatformParser.reset(createELFAsmParser());
     break;
+  case MCContext::IsGOFF:
+    report_fatal_error("GOFFAsmParser support not implemented yet");
   case MCContext::IsWasm:
     PlatformParser.reset(createWasmAsmParser());
     break;
   case MCContext::IsXCOFF:
     PlatformParser.reset(createXCOFFAsmParser());
     break;
   }
 

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

case MCContext::IsELF:
     CurrentFormat = ELF;
     break;
   case MCContext::IsCOFF:
     CurrentFormat = COFF;
     break;
   case MCContext::IsWasm:
     CurrentFormat = WASM;
     break;
+  case MCContext::IsGOFF:
   case MCContext::IsXCOFF:
     llvm_unreachable("unexpected object format");
     break;
   }
 
   if (~Prefix->SupportedFormats & CurrentFormat) {
     Error(Parser.getTok().getLoc(),
           "cannot represent relocation in the current file format");

llvm/lib/Target/SystemZ/SystemZTargetMachine.cpp

static std::string computeDataLayout(const Triple &TT, StringRef CPU,
   Ret += "-a:8:16";
 
   // Integer registers are 32 or 64 bits.
   Ret += "-n32:64";
 
   return Ret;
 }
 
+static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
+  if (TT.isOSzOS())
+    return std::make_unique<TargetLoweringObjectFileGOFF>();
+
+  // Note: Some times run with -triple s390x-unknown.
+  // In this case, default to ELF unless z/OS specifically provided.
+  return std::make_unique<TargetLoweringObjectFileELF>();
+}
+
 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
   // Static code is suitable for use in a dynamic executable; there is no
   // separate DynamicNoPIC model.
   if (!RM.hasValue() || *RM == Reloc::DynamicNoPIC)
     return Reloc::Static;
   return *RM;
 }
 
SystemZTargetMachine::SystemZTargetMachine(const Target &T, const Triple &TT,
                                            Optional<Reloc::Model> RM,
                                            Optional<CodeModel::Model> CM,
                                            CodeGenOpt::Level OL, bool JIT)
     : LLVMTargetMachine(
           T, computeDataLayout(TT, CPU, FS), TT, CPU, FS, Options,
           getEffectiveRelocModel(RM),
           getEffectiveSystemZCodeModel(CM, getEffectiveRelocModel(RM), JIT),
           OL),
-      TLOF(std::make_unique<TargetLoweringObjectFileELF>()) {
+      TLOF(createTLOF(getTargetTriple())) {
   initAsmInfo();
 }
 
 SystemZTargetMachine::~SystemZTargetMachine() = default;
 
 const SystemZSubtarget *
 SystemZTargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");

llvm/test/CodeGen/SystemZ/zos-simple-test.ll

+; A simple, barebones test to check whether assembly can be emitted
+; for the z/OS target
+; RUN: llc < %s -mtriple=s390x-ibm-zos | FileCheck %s
+
+@a = global i32 0, align 4
+
+define signext i32 @main() {
+; CHECK: .section ".text"
+; CHECK: main:
+; CHECK: .section "a"
+entry:
+  ret i32 0
+}