Rework based on reviewer comment.

Author: redstar

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

@@ -316,6 +316,8 @@ class TargetLoweringObjectFileXCOFF : public TargetLoweringObjectFile {
 };
 
 class TargetLoweringObjectFileGOFF : public TargetLoweringObjectFile {
+  std::string DefaultRootSDName;
+  std::string DefaultADAPRName;
 public:
   TargetLoweringObjectFileGOFF();
   ~TargetLoweringObjectFileGOFF() override = default;

llvm/include/llvm/MC/MCContext.h

@@ -270,6 +270,21 @@ class MCContext {
     }
   };
 
+  struct GOFFSectionKey {
+    std::string SectionName;
+    GOFF::ESDSymbolType SymbolType;
+
+    GOFFSectionKey(StringRef SectionName, GOFF::ESDSymbolType SymbolType)
+        : SectionName(SectionName), SymbolType(SymbolType) {}
+
+    bool operator<(const GOFFSectionKey &Other) const {
+      if (SymbolType == Other.SymbolType) {
+        return SectionName < Other.SectionName;
+      }
+      return SymbolType < Other.SymbolType;
+    }
+  };
+
   struct WasmSectionKey {
     std::string SectionName;
     StringRef GroupName;
@@ -323,7 +338,7 @@ class MCContext {
   StringMap<MCSectionMachO *> MachOUniquingMap;
   std::map<COFFSectionKey, MCSectionCOFF *> COFFUniquingMap;
   StringMap<MCSectionELF *> ELFUniquingMap;
-  std::map<std::string, MCSectionGOFF *> GOFFUniquingMap;
+  std::map<GOFFSectionKey, MCSectionGOFF *> GOFFUniquingMap;
   std::map<WasmSectionKey, MCSectionWasm *> WasmUniquingMap;
   std::map<XCOFFSectionKey, MCSectionXCOFF *> XCOFFUniquingMap;
   StringMap<MCSectionDXContainer *> DXCUniquingMap;
@@ -601,35 +616,22 @@ class MCContext {
                                                    unsigned EntrySize);
 
 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);
+  MCSectionGOFF *getGOFFSection(SectionKind Kind,
+                                GOFF::ESDSymbolType SymbolType, StringRef Name,
+                                GOFF::SDAttr SDAttributes,
+                                GOFF::EDAttr EDAttributes,
+                                GOFF::PRAttr PRAttributes, MCSection *Parent);
 
 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.
-  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef EDName,
-                                GOFF::EDAttr EDAttributes, StringRef LDorPRName,
-                                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);
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef Name,
+                                GOFF::SDAttr SDAttributes,
+                                MCSection *Parent = nullptr);
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef Name,
+                                GOFF::EDAttr EDAttributes,
+                                MCSection *Parent = nullptr);
+  MCSectionGOFF *getGOFFSection(SectionKind Kind, StringRef Name,
+                                GOFF::PRAttr PRAttributes,
+                                MCSection *Parent = nullptr);
 
   MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                 StringRef COMDATSymName, int Selection,

llvm/include/llvm/MC/MCGOFFStreamer.h

@@ -29,6 +29,7 @@ class MCGOFFStreamer : public MCObjectStreamer {
   ~MCGOFFStreamer() override;
 
   void initSections(bool NoExecStack, const MCSubtargetInfo &STI) override;
+  void changeSection(MCSection *Section, uint32_t Subsection = 0) override;
 
   GOFFObjectWriter &getWriter();
 

llvm/include/llvm/MC/MCObjectFileInfo.h

@@ -230,8 +230,11 @@ class MCObjectFileInfo {
   MCSection *GLJMPSection = nullptr;
 
   // GOFF specific sections.
-  MCSection *PPA2ListSection = nullptr;
-  MCSection *ADASection = nullptr;
+  MCSection *RootSDSection = nullptr;
+  MCSection *PPA2ListEDSection = nullptr;
+  MCSection *PPA2ListPRSection = nullptr;
+  MCSection *ADAEDSection = nullptr;
+  MCSection *ADAPRSection = nullptr;
   MCSection *IDRLSection = nullptr;
 
   // XCOFF specific sections
@@ -436,8 +439,11 @@ class MCObjectFileInfo {
   MCSection *getGLJMPSection() const { return GLJMPSection; }
 
   // GOFF specific sections.
-  MCSection *getPPA2ListSection() const { return PPA2ListSection; }
-  MCSection *getADASection() const { return ADASection; }
+  MCSection *getRootSDSection() const { return RootSDSection; }
+  MCSection *getPPA2ListEDSection() const { return PPA2ListEDSection; }
+  MCSection *getPPA2ListSection() const { return PPA2ListPRSection; }
+  MCSection *getADAEDSection() const { return ADAEDSection; }
+  MCSection *getADASection() const { return ADAPRSection; }
   MCSection *getIDRLSection() const { return IDRLSection; }
 
   // XCOFF specific sections

llvm/include/llvm/MC/MCSectionGOFF.h

@@ -15,96 +15,96 @@
 #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/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 class MCExpr;
 
 class MCSectionGOFF final : public MCSection {
-private:
-  // The names of the GOFF symbols.
-  StringRef SDName;
-  StringRef EDName;
-  StringRef LDorPRName;
+  // Parent of this section. Implies that the parent is emitted first.
+  MCSectionGOFF *Parent;
 
   // 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)
-  };
+  // The type of this section.
+  GOFF::ESDSymbolType SymbolType;
+
+  // Indicates that the ED symbol needs to set the length of the section.
+  unsigned RequiresLength : 1;
 
-private:
-  SectionFlags Flags;
+  // Indicates that the PR symbol needs to set the length of the section to a
+  // non-zero value.
+  unsigned RequiresNonZeroLength : 1;
 
   friend class MCContext;
-  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),
-        LDAttributes(LDAttributes), PRAttributes(PRAttributes), Flags(Flags) {}
+  MCSectionGOFF(StringRef Name, SectionKind K, GOFF::ESDSymbolType SymbolType,
+                GOFF::SDAttr SDAttributes, GOFF::EDAttr EDAttributes,
+                GOFF::PRAttr PRAttributes, MCSectionGOFF *Parent = nullptr)
+      : MCSection(SV_GOFF, Name, K.isText(), /*IsVirtual=*/false, nullptr),
+        Parent(Parent), SDAttributes(SDAttributes), EDAttributes(EDAttributes),
+        PRAttributes(PRAttributes), SymbolType(SymbolType) {}
 
 public:
   void printSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             uint32_t /*Subsection*/) const override {
-    if (!usesRootSD())
-      OS << getSDName() << " CSECT\n";
-    OS << getEDName() << " CATTR\n";
-    if ((hasLD() || hasPR()) && !getLDorPRName().empty())
-      OS << getLDorPRName() << " XATTR\n";
+    ;
+    switch (SymbolType) {
+    case GOFF::ESD_ST_SectionDefinition:
+      OS << Name << " CSECT\n";
+      break;
+    case GOFF::ESD_ST_ElementDefinition:
+      OS << Name << " CATTR\n";
+      break;
+    case GOFF::ESD_ST_PartReference:
+      OS << Name << " XATTR\n";
+      break;
+    default:
+      llvm_unreachable("Wrong section type");
+    }
   }
 
   bool useCodeAlign() const override { return false; }
 
-  // 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) {
-    assert(!(Flags & UsesRootSD) && "Uses root SD");
-    SDName = Name;
+  // Return the id of the section. It is the 1-based ordinal number.
+  unsigned getId() const { return getOrdinal() + 1; }
+
+  // Return the parent section.
+  MCSectionGOFF *getParent() const { return Parent; }
+
+  // Returns the type of this section.
+  GOFF::ESDSymbolType getSymbolType() const { return SymbolType; }
+
+  bool isSD() const { return SymbolType == GOFF::ESD_ST_SectionDefinition; }
+  bool isED() const { return SymbolType == GOFF::ESD_ST_ElementDefinition; }
+  bool isPR() const { return SymbolType == GOFF::ESD_ST_PartReference; }
+
+  // Accessors to the attributes.
+  GOFF::SDAttr getSDAttributes() const {
+    assert(SymbolType == GOFF::ESD_ST_SectionDefinition && "Not PR symbol");
+    return SDAttributes;
   }
-  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::EDAttr getEDAttributes() const {
+    assert(SymbolType == GOFF::ESD_ST_ElementDefinition && "Not PR symbol");
+    return EDAttributes;
   }
   GOFF::PRAttr getPRAttributes() const {
-    assert(Flags & HasPR && "PR not available");
+    assert(SymbolType == GOFF::ESD_ST_PartReference && "Not PR symbol");
     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 requiresLength() const { return RequiresLength; }
+  bool requiresNonZeroLength() const { return RequiresNonZeroLength; }
+
+  void setName(StringRef SectionName) { Name = SectionName; }
 
   static bool classof(const MCSection *S) { return S->getVariant() == SV_GOFF; }
 };

llvm/include/llvm/MC/MCSymbolGOFF.h

@@ -13,15 +13,38 @@
 #ifndef LLVM_MC_MCSYMBOLGOFF_H
 #define LLVM_MC_MCSYMBOLGOFF_H
 
+#include "llvm/BinaryFormat/GOFF.h"
+#include "llvm/MC/MCGOFFAttributes.h"
+#include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolTableEntry.h"
 
 namespace llvm {
 
 class MCSymbolGOFF : public MCSymbol {
+  // Associated data area of the section. Needs to be emitted first.
+  MCSectionGOFF *ADA;
+
+  GOFF::LDAttr LDAttributes;
+
+  enum SymbolFlags : uint16_t {
+    SF_LD = 0x01, // LD attributes are set.
+  };
+
 public:
   MCSymbolGOFF(const MCSymbolTableEntry *Name, bool IsTemporary)
       : MCSymbol(SymbolKindGOFF, Name, IsTemporary) {}
+
+  void setLDAttributes(GOFF::LDAttr Attr) {
+    modifyFlags(SF_LD, SF_LD);
+    LDAttributes = Attr;
+  }
+  GOFF::LDAttr getLDAttributes() const { return LDAttributes; }
+  bool hasLDAttributes() const { return getFlags() & SF_LD; }
+
+  void setADA(MCSectionGOFF *AssociatedDataArea) { ADA = AssociatedDataArea; }
+  MCSectionGOFF *getADA() const { return ADA; }
+
   static bool classof(const MCSymbol *S) { return S->isGOFF(); }
 };
 } // end namespace llvm