Remove the class GOFFSymbolMapper

Author: redstar

llvm/include/llvm/BinaryFormat/GOFF.h

@@ -204,8 +204,8 @@ class Flags {
 };
 
 // Structure for the flag field of a symbol. See
-// https://www.ibm.com/docs/en/zos/3.1.0?topic=formats-external-symbol-definition-record ,
-// offset 41, for the definition.
+// https://www.ibm.com/docs/en/zos/3.1.0?topic=formats-external-symbol-definition-record
+// at offset 41 for the definition.
 struct SymbolFlags {
   Flags SymFlags;
 

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

@@ -320,6 +320,8 @@ class TargetLoweringObjectFileGOFF : public TargetLoweringObjectFile {
   TargetLoweringObjectFileGOFF();
   ~TargetLoweringObjectFileGOFF() override = default;
 
+  void getModuleMetadata(Module &M) override;
+
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,

llvm/include/llvm/MC/MCContext.h

@@ -19,8 +19,10 @@
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCAsmMacro.h"
 #include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCGOFFAttributes.h"
 #include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSymbolTableEntry.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Allocator.h"
@@ -54,7 +56,6 @@ class MCSection;
 class MCSectionCOFF;
 class MCSectionDXContainer;
 class MCSectionELF;
-class MCSectionGOFF;
 class MCSectionMachO;
 class MCSectionSPIRV;
 class MCSectionWasm;
@@ -599,8 +600,36 @@ class MCContext {
                                                    unsigned Flags,
                                                    unsigned EntrySize);
 
-  MCSectionGOFF *getGOFFSection(StringRef Section, SectionKind Kind,
-                                MCSection *Parent, uint32_t Subsection = 0);
+private:
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef SDName,
+                                GOFF::SDAttr SDAttributes, StringRef EDName,
+                                GOFF::EDAttr EDAttributes, StringRef LDorPRName,
+                                GOFF::LDAttr LDAttributes,
+                                GOFF::PRAttr PRAttributes,
+                                MCSectionGOFF::SectionFlags Flags);
+
+public:
+  // Create a section with SD/ED/LD symbols.
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef SDName,
+                                GOFF::SDAttr SDAttributes, StringRef EDName,
+                                GOFF::EDAttr EDAttributes, StringRef LDorPRName,
+                                GOFF::LDAttr LDAttributes);
+  // Create a section with SD/ED/PR symbols.
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef SDName,
+                                GOFF::SDAttr SDAttributes, StringRef EDName,
+                                GOFF::EDAttr EDAttributes, StringRef LDorPRName,
+                                GOFF::PRAttr PRAttributes);
+  // Create a section with root-SD/ED/LD symbols, using the root-SD name for LD.
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef EDName,
+                                GOFF::EDAttr EDAttributes,
+                                GOFF::LDAttr LDAttributes);
+  // Create a section with root-SD/ED/PR symbols.
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef EDName,
+                                GOFF::EDAttr EDAttributes, StringRef PRName,
+                                GOFF::PRAttr PRAttributes);
+  // Create a section with root-SD/ED symbols.
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef EDName,
+                                GOFF::EDAttr EDAttributes);
 
   MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                 StringRef COMDATSymName, int Selection,

llvm/include/llvm/MC/MCGOFFSymbolMapper.h renamed to llvm/include/llvm/MC/MCGOFFAttributes.h

@@ -1,30 +1,23 @@
-//===- MCGOFFSymbolMapper.h - Maps MC section/symbol to GOFF symbols ------===//
+//===- MCGOFFAttributes.h - Attributes of GOFF symbols --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Maps a section or a symbol to the GOFF symbols it is composed of, and their
-// attributes.
+// Defines the various attribute collections defining GOFF symbols.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_MC_MCGOFFSYMBOLMAPPER_H
-#define LLVM_MC_MCGOFFSYMBOLMAPPER_H
+#ifndef LLVM_MC_MCGOFFATTRIBUTES_H
+#define LLVM_MC_MCGOFFATTRIBUTES_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/GOFF.h"
-#include "llvm/Support/Alignment.h"
-#include <string>
-#include <utility>
 
 namespace llvm {
-class MCAssembler;
-class MCContext;
-class MCSectionGOFF;
-
+namespace GOFF {
 // An "External Symbol Definition" in the GOFF file has a type, and depending on
 // the type a different subset of the fields is used.
 //
@@ -40,8 +33,8 @@ class MCSectionGOFF;
 // the whole data is pulled into the resulting executable, and the addresses
 // given by the LD symbols are resolved.
 //
-// The alternative is to use a Part Definition (PR). In this case, the data (in a
-// text record) is associated with the part. When binding, only the data of
+// The alternative is to use a Part Definition (PR). In this case, the data (in
+// a text record) is associated with the part. When binding, only the data of
 // referenced PRs is pulled into the resulting binary.
 //
 // Both approaches are used, which means that the equivalent of a section in ELF
@@ -95,54 +88,40 @@ struct PRAttr {
   uint32_t SortKey = 0;
 };
 
-struct GOFFSectionData {
-  // Name and attributes of SD symbol.
-  StringRef SDName;
-  SDAttr SDAttributes;
-
-  // Name and attributes of ED symbol.
-  StringRef EDName;
-  EDAttr EDAttributes;
-
-  // Name and attributes of LD or PR symbol.
-  StringRef LDorPRName;
-  LDAttr LDAttributes;
-  PRAttr PRAttributes;
+// Class names and other values depending on AMODE64 or AMODE31, and other
+// environment properties.
+template <bool Is64Bit>
+constexpr StringLiteral CODE =
+    Is64Bit ? StringLiteral("C_CODE64") : StringLiteral("C_CODE");
 
-  // Indicates if there is a LD or PR symbol.
-  enum { None, LD, PR } Tag;
-
-  // Indicates if the SD symbol is to root symbol (aka the Csect Code).
-  bool IsSDRootSD;
-};
+template <bool Is64Bit>
+constexpr StringLiteral WSA =
+    Is64Bit ? StringLiteral("C_WSA64") : StringLiteral("C_WSA");
 
-class GOFFSymbolMapper {
-  MCContext &Ctx;
+template <bool Is64Bit>
+constexpr StringLiteral DATA =
+    Is64Bit ? StringLiteral("C_DATA64") : StringLiteral("C_DATA");
 
-  std::string RootSDName;
-  SDAttr RootSDAttributes;
+template <bool Is64Bit>
+constexpr StringLiteral PPA2 =
+    Is64Bit ? StringLiteral("C_@@QPPA2") : StringLiteral("C_@@PPA2");
 
-  std::string ADALDName;
+template <bool Is64Bit>
+constexpr GOFF::ESDAmode AMODE =
+    Is64Bit ? GOFF::ESD_AMODE_64 : GOFF::ESD_AMODE_ANY;
 
-  StringRef BaseName;
+template <bool Is64Bit>
+constexpr GOFF::ESDRmode RMODE =
+    Is64Bit ? GOFF::ESD_RMODE_64 : GOFF::ESD_RMODE_31;
 
-  bool IsCsectCodeNameEmpty;
-  bool Is64Bit;
-  bool UsesXPLINK;
-
-public:
-  GOFFSymbolMapper(MCContext &Ctx);
-  GOFFSymbolMapper(MCAssembler &Asm);
-
-  // Required order: .text first, then .ada.
-  std::pair<GOFFSectionData, bool> getSection(const MCSectionGOFF &Section);
-
-  void setBaseName();
-  void determineRootSD(StringRef CSectCodeName);
-  llvm::StringRef getRootSDName() const;
-  const SDAttr &getRootSD() const;
-};
+template <bool IsXPLINK>
+constexpr GOFF::ESDLinkageType LINKAGE =
+    IsXPLINK ? GOFF::ESD_LT_XPLink : GOFF::ESD_LT_OS;
 
+template <bool IsXPLINK>
+constexpr GOFF::ESDLoadingBehavior LOADBEHAVIOR =
+    IsXPLINK ? GOFF::ESD_LB_Initial : GOFF::ESD_LB_Deferred;
+} // namespace GOFF
 } // namespace llvm
 
 #endif

llvm/include/llvm/MC/MCGOFFStreamer.h

@@ -16,6 +16,9 @@ namespace llvm {
 class GOFFObjectWriter;
 
 class MCGOFFStreamer : public MCObjectStreamer {
+  std::string RootSDName;
+  std::string ADAPRName;
+
 public:
   MCGOFFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
                  std::unique_ptr<MCObjectWriter> OW,
@@ -25,6 +28,8 @@ class MCGOFFStreamer : public MCObjectStreamer {
 
   ~MCGOFFStreamer() override;
 
+  void initSections(bool NoExecStack, const MCSubtargetInfo &STI) override;
+
   GOFFObjectWriter &getWriter();
 
   bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {

llvm/include/llvm/MC/MCObjectFileInfo.h

@@ -230,8 +230,6 @@ class MCObjectFileInfo {
   MCSection *GLJMPSection = nullptr;
 
   // GOFF specific sections.
-  MCSection *PPA1Section = nullptr;
-  MCSection *PPA2Section = nullptr;
   MCSection *PPA2ListSection = nullptr;
   MCSection *ADASection = nullptr;
   MCSection *IDRLSection = nullptr;
@@ -438,8 +436,6 @@ class MCObjectFileInfo {
   MCSection *getGLJMPSection() const { return GLJMPSection; }
 
   // GOFF specific sections.
-  MCSection *getPPA1Section() const { return PPA1Section; }
-  MCSection *getPPA2Section() const { return PPA2Section; }
   MCSection *getPPA2ListSection() const { return PPA2ListSection; }
   MCSection *getADASection() const { return ADASection; }
   MCSection *getIDRLSection() const { return IDRLSection; }

llvm/include/llvm/MC/MCSectionGOFF.h

@@ -15,7 +15,9 @@
 #ifndef LLVM_MC_MCSECTIONGOFF_H
 #define LLVM_MC_MCSECTIONGOFF_H
 
+#include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/BinaryFormat/GOFF.h"
+#include "llvm/MC/MCGOFFAttributes.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -25,13 +27,38 @@ class MCExpr;
 
 class MCSectionGOFF final : public MCSection {
 private:
-  MCSection *Parent;
-  uint32_t Subsection;
+  // The names of the GOFF symbols.
+  StringRef SDName;
+  StringRef EDName;
+  StringRef LDorPRName;
+
+  // The attributes of the GOFF symbols.
+  GOFF::SDAttr SDAttributes;
+  GOFF::EDAttr EDAttributes;
+  GOFF::LDAttr LDAttributes;
+  GOFF::PRAttr PRAttributes;
+
+public:
+  enum SectionFlags {
+    UsesRootSD = 1,     // Uses the common root SD.
+    HasLD = 2,          // Has a LD symbol.
+    HasPR = 4,          // Has a PR symbol.
+    LDorPRNameIsSD = 8, // The LD or PR name is the same as the SD name.
+    LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ 8)
+  };
+
+private:
+  SectionFlags Flags;
+  bool IsADA;
 
   friend class MCContext;
-  MCSectionGOFF(StringRef Name, SectionKind K, MCSection *P, uint32_t Sub)
-      : MCSection(SV_GOFF, Name, K.isText(), /*IsVirtual=*/false, nullptr),
-        Parent(P), Subsection(Sub) {}
+  MCSectionGOFF(StringRef SynName, SectionKind K, SectionFlags Flags,
+                StringRef SDName, GOFF::SDAttr SDAttributes, StringRef EDName,
+                GOFF::EDAttr EDAttributes, StringRef LDorPRName,
+                GOFF::LDAttr LDAttributes, GOFF::PRAttr PRAttributes)
+      : MCSection(SV_GOFF, SynName, K.isText(), /*IsVirtual=*/false, nullptr),
+        SDName(SDName), EDName(EDName), LDorPRName(LDorPRName),
+        SDAttributes(SDAttributes), EDAttributes(EDAttributes), Flags(Flags) {}
 
 public:
   void printSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
@@ -42,8 +69,38 @@ class MCSectionGOFF final : public MCSection {
 
   bool useCodeAlign() const override { return false; }
 
-  MCSection *getParent() const { return Parent; }
-  uint32_t getSubsection() const { return Subsection; }
+  // Accessors to the various symbol names.
+  StringRef getSDName() const { return SDName; };
+  StringRef getEDName() const { return EDName; };
+  StringRef getLDorPRName() const {
+    assert(Flags & (HasLD | HasPR) && "LD/PR name not available");
+    return (Flags & LDorPRNameIsSD) ? SDName : LDorPRName;
+  };
+
+  // Setters for the SD and LD/PR symbol names.
+  void setSDName(StringRef Name) { SDName = Name; }
+  void setLDorPRName(StringRef Name) { LDorPRName = Name; }
+
+  // Accessors to the various attributes.
+  GOFF::SDAttr getSDAttributes() const { return SDAttributes; }
+  GOFF::EDAttr getEDAttributes() const { return EDAttributes; }
+  GOFF::LDAttr getLDAttributes() const {
+    assert(Flags & HasLD && "LD not available");
+    return LDAttributes;
+  }
+  GOFF::PRAttr getPRAttributes() const {
+    assert(Flags & HasPR && "PR not available");
+    return PRAttributes;
+  }
+
+  // Query various flags.
+  bool usesRootSD() const { return Flags & UsesRootSD; }
+  bool hasLD() const { return Flags & HasLD; }
+  bool hasPR() const { return Flags & HasPR; }
+  bool isLDorPRNameTheSD() const { return Flags & LDorPRNameIsSD; }
+
+  bool isADA() const { return IsADA; }
+  void setADA() { IsADA = true; }
 
   static bool classof(const MCSection *S) { return S->getVariant() == SV_GOFF; }
 };