Fix build error + some issues with section symbols

Everybody0523 · Everybody0523 · commit c1bfe45a205d · 2024-04-08T01:10:13.000-04:00
diff --git a/llvm/include/llvm/MC/MCContext.h b/llvm/include/llvm/MC/MCContext.h
@@ -660,7 +660,7 @@ class MCContext {
                                 GOFF::ESDLoadingBehavior LoadBehavior = GOFF::ESD_LB_Initial,
                                 GOFF::ESDBindingScope BindingScope = GOFF::ESD_BSC_Unspecified,
                                 bool isRooted = false,
-                                MCSymbolGOFF *TextOwner = nullptr);
+                                const MCSymbolGOFF *TextOwner = nullptr);
 
   MCSectionGOFF *
   getGOFFSection(StringRef Section, SectionKind Kind,
@@ -671,7 +671,7 @@ class MCContext {
                  GOFF::ESDBindingAlgorithm BindAlgorithm = GOFF::ESD_BA_Concatenate,
                  GOFF::ESDLoadingBehavior LoadBehavior = GOFF::ESD_LB_Initial,
                  GOFF::ESDBindingScope BindingScope = GOFF::ESD_BSC_Unspecified,
-                 bool isRooted = false, MCSymbolGOFF * TextOwner = nullptr);
+                 bool isRooted = false, const MCSymbolGOFF * TextOwner = nullptr);
 
   MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                 SectionKind Kind, StringRef COMDATSymName,
diff --git a/llvm/include/llvm/MC/MCSectionGOFF.h b/llvm/include/llvm/MC/MCSectionGOFF.h
@@ -52,15 +52,15 @@ class MCSectionGOFF final : public MCSection {
   /// TextOwner - Valid if owned the text record containing the body of this section
   /// is not owned by an ED Symbol. The MCSymbol that represents the part or label that
   /// actually owns the TXT Record.
-  MCSymbolGOFF *TextOwner = nullptr;
+  const MCSymbolGOFF *TextOwner = nullptr;
 
   friend class MCContext;
   MCSectionGOFF(StringRef Name, SectionKind K, MCSection *P, const MCExpr *Sub)
       : MCSection(SV_GOFF, Name, K, nullptr), Parent(P), SubsectionId(Sub) {}
   
   MCSectionGOFF(StringRef Name, SectionKind K, MCSection *P, const MCExpr *Sub,
                 GOFF::ESDTextStyle TextStyle, GOFF::ESDBindingAlgorithm BindAlgorithm,
-                GOFF::ESDLoadingBehavior LoadBehavior, GOFF::ESDBindingScope BindingScope, bool IsRooted, MCSymbolGOFF *TextOwner)
+                GOFF::ESDLoadingBehavior LoadBehavior, GOFF::ESDBindingScope BindingScope, bool IsRooted, const MCSymbolGOFF *TextOwner)
       : MCSection(SV_GOFF, Name, K, nullptr), Parent(P), SubsectionId(Sub),
         TextStyle(TextStyle), BindAlgorithm(BindAlgorithm), LoadBehavior(LoadBehavior), BindingScope(BindingScope), IsRooted(IsRooted), TextOwner(TextOwner) {}
 
@@ -124,7 +124,7 @@ class MCSectionGOFF final : public MCSection {
       case GOFF::GOFFSectionType::Static:
         return "C_WSA64";
       case GOFF::GOFFSectionType::PPA2Offset:
-        return "C_QPPA2";
+        return "C_@@QPPA2";
       case GOFF::GOFFSectionType::B_IDRL:
         return "B_IDRL";
       case GOFF::GOFFSectionType::Other:
@@ -133,7 +133,7 @@ class MCSectionGOFF final : public MCSection {
     return "";
   }
 
-  std::optional<MCSymbolGOFF *> getTextOwner() const {
+  std::optional<const MCSymbolGOFF *> getTextOwner() const {
     if (TextOwnedByED)
       return std::nullopt;
     else if (TextOwner)
diff --git a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp
@@ -2738,20 +2738,21 @@ MCSection *TargetLoweringObjectFileGOFF::getExplicitSectionGlobal(
 MCSection *TargetLoweringObjectFileGOFF::getSectionForLSDA(
     const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
   std::string Name = ".gcc_exception_table." + F.getName().str();
+  const auto *Symbol = cast<MCSymbolGOFF>(&FnSym);
   return getContext().getGOFFSection(Name, SectionKind::getData(),
                                          GOFF::ESD_TS_ByteOriented,
                                          GOFF::ESD_BA_Merge,
                                          GOFF::ESD_LB_Deferred,
                                          GOFF::ESD_BSC_Section,
-                                         true, &FnSym);
+                                         true, Symbol);
 }
 
 MCSection *TargetLoweringObjectFileGOFF::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
-  auto *Symbol = cast<MCSymbolGOFF *>(TM.getSymbol(GO));
+  auto *Symbol = cast<MCSymbolGOFF>(TM.getSymbol(GO));
   if (Kind.isData() || Kind.isBSS()) {
-    auto BindingScope = Symbol.isExternal()
-                          ? (Symbol.isExported() ? GOFF::ESD_BSC_ImportExport
+    auto BindingScope = Symbol->isExternal()
+                          ? (Symbol->isExported() ? GOFF::ESD_BSC_ImportExport
                                                  : GOFF::ESD_BSC_Library)
                           : GOFF::ESD_BSC_Section;
     return getContext().getGOFFSection(Symbol->getName(), Kind,
diff --git a/llvm/lib/MC/GOFFObjectWriter.cpp b/llvm/lib/MC/GOFFObjectWriter.cpp
@@ -326,6 +326,8 @@ class GOFFObjectWriter : public MCObjectWriter {
   uint32_t EntryEDEsdId;
   uint32_t CodeLDEsdId;
 
+  std::string FileName;
+
 public:
   GOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW,
                    raw_pwrite_stream &OS)
@@ -339,16 +341,33 @@ class GOFFObjectWriter : public MCObjectWriter {
 
   void writeSymbol(const GOFFSymbol &Symbol, const MCAsmLayout &Layout);
 
-  void writeADAandCodeSectionSymbols(MCAssembler &Asm,
-                                     const MCAsmLayout &Layout);
+  const MCSectionGOFF *getCodeSection(const MCAssembler &Asm) const {
+    for (const MCSection &MCSec : Asm) {
+      auto &GSec = cast<MCSectionGOFF>(MCSec);
+      if (GSec.isCode())
+        return &GSec;
+    }
+    llvm_unreachable("Code CSect not found!\n");
+    return nullptr;
+  }
+
+  const MCSectionGOFF *getStaticSection(const MCAssembler &Asm) const {
+    for (const MCSection &MCSec : Asm) {
+      auto &GSec = cast<MCSectionGOFF>(MCSec);
+      if (GSec.isStatic())
+        return &GSec;
+    }
+    llvm_unreachable("Static CSect not found!\n");
+    return nullptr;
+  }
 
   std::pair<GOFFSymbol, GOFFSymbol> getSDEDSymbolsForSection(const MCSectionGOFF& GSection, const MCAsmLayout Layout);
 
-  // Write out all ESD Symbols that own a section. GOFF doesn't have
+  // Write out all ESD Symbols that make up a section. GOFF doesn't have
   // "sections" in the way other object file formats like ELF do; instead
   // a GOFF section is defined as a triple of ESD Symbols (SD, ED, PR/LD).
-  // The PR/LD symbol should own a TXT record that contains the actual
-  // data of the section.
+  // The ED or PR symbol should own a TXT Record that contains the contents
+  // of the section itself
   void writeSectionSymbols(const MCSectionGOFF &GSection, MCAssembler &Asm, const MCAsmLayout &Layout);
 
   void writeText(const MCSectionGOFF *MCSec, uint32_t EsdId,
@@ -528,27 +547,10 @@ GOFFSymbol GOFFObjectWriter::createWSASymbol(uint32_t ParentEsdId,
   return WSA;
 }
 
-static uint32_t getADASectionLength(MCAssembler &Asm,
-                                    const MCAsmLayout &Layout) {
-  uint32_t SecLen = 0;
-  for (const MCSection &MCSec : Asm) {
-    auto &GSec = cast<MCSectionGOFF>(MCSec);
-    if (GSec.isStatic()) {
-      SecLen = Layout.getSectionAddressSize(&MCSec);
-    }
-  }
-
-  // The ADA section is not allowed to be zero-length. We also want to
-  // avoid odd alignments, so we use 2 bytes.
-  return std::max(SecLen, 2u);
-}
-
 void GOFFObjectWriter::defineRootSD(MCAssembler &Asm,
                                     const MCAsmLayout &Layout) {
-  StringRef FileName = "";
-  if (!Asm.getFileNames().empty())
-    FileName = sys::path::stem((*(Asm.getFileNames().begin())).first);
-  RootSD = createSDSymbol(FileName.str().append("#C"));
+  std::string RootName = FileName + "#C";
+  RootSD = createSDSymbol(RootName);
   RootSD.BindingScope = GOFF::ESD_BSC_Section;
   RootSD.Executable = GOFF::ESD_EXE_CODE;
 }
@@ -659,8 +661,8 @@ void GOFFObjectWriter::writeSymbolDeclaredInModule(const MCSymbolGOFF &Symbol,
 
 void GOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                 const MCAsmLayout &Layout) {
-  LLVM_DEBUG(dbgs() << "Entering " << __FUNCTION__ << "\n");
-
+  if (!Asm.getFileNames().empty())
+    FileName = sys::path::stem((*(Asm.getFileNames().begin())).first);
   defineRootSD(Asm, Layout);
 }
 
@@ -863,50 +865,6 @@ void GOFFObjectWriter::writeSymbol(const GOFFSymbol &Symbol,
   OS.write(Name.data(), NameLength); // Name
 }
 
-void GOFFObjectWriter::writeADAandCodeSectionSymbols(
-    MCAssembler &Asm, const MCAsmLayout &Layout) {
-  // Write ESD Records for ADA Section
-  GOFFSymbol ADAED = createWSASymbol(RootSD.EsdId, true);
-  StringRef FileName = "";
-  if (!Asm.getFileNames().empty())
-    FileName = sys::path::stem((*(Asm.getFileNames().begin())).first);
-
-  GOFFSymbol ADA;
-  ADA = createPRSymbol(FileName.str().append("#S"), ADAED.EsdId,
-                       GOFF::ESD_NS_Parts, GOFF::ESD_EXE_DATA,
-                       GOFF::ESD_ALIGN_Quadword, GOFF::ESD_BSC_Section,
-                       getADASectionLength(Asm, Layout));
-  writeSymbol(ADAED, Layout);
-  writeSymbol(ADA, Layout);
-  ADAPREsdId = ADA.EsdId;
-
-  // Write ESD Records for Code Section
-  GOFFSymbol ED =
-      createEDSymbol("C_CODE64", RootSD.EsdId, 0, GOFF::ESD_EXE_CODE, true);
-
-  for (const MCSection &MCSec : Asm) {
-    auto &GSec = cast<MCSectionGOFF>(MCSec);
-    if (GSec.isCode()) {
-      if (!ED.SectionLength)
-        ED.SectionLength = Layout.getSectionAddressSize(&MCSec);
-    }
-  }
-
-  GOFFSymbol LD = createLDSymbol(RootSD.Name, ED.EsdId);
-  LD.Executable = GOFF::ESD_EXE_CODE;
-  if (RootSD.BindingScope == GOFF::ESD_BSC_Section)
-    LD.BindingScope = GOFF::ESD_BSC_Section;
-  else
-    LD.BindingScope = GOFF::ESD_BSC_Library;
-
-  LD.ADAEsdId = ADAPREsdId;
-
-  EntryEDEsdId = ED.EsdId;
-  CodeLDEsdId = LD.EsdId;
-  writeSymbol(ED, Layout);
-  writeSymbol(LD, Layout);
-}
-
 std::pair<GOFFSymbol, GOFFSymbol> GOFFObjectWriter::getSDEDSymbolsForSection(const MCSectionGOFF& GSection, const MCAsmLayout Layout) {
   GOFFSymbol SD = GSection.getRooted() ? RootSD : createSDSymbol(GSection.getName());
 
@@ -922,7 +880,6 @@ std::pair<GOFFSymbol, GOFFSymbol> GOFFObjectWriter::getSDEDSymbolsForSection(con
   return std::make_pair(SD, ED);
 }
 
-
 void GOFFObjectWriter::writeSectionSymbols(const MCSectionGOFF &GSection,
                                            MCAssembler &Asm,
                                            const MCAsmLayout &Layout) {
@@ -936,6 +893,8 @@ void GOFFObjectWriter::writeSectionSymbols(const MCSectionGOFF &GSection,
   if (GSection.isCode()) {
     GOFFSymbol LD = createLDSymbol(RootSD.Name, SDEDSymbols.second.EsdId);
     LD.BindingScope = GOFF::ESD_BSC_Section;
+    EntryEDEsdId = SDEDSymbols.second.EsdId;
+    CodeLDEsdId = LD.EsdId;
     GOFFSection GoffSec = GOFFSection(LD.EsdId, SDEDSymbols.second.EsdId, SDEDSymbols.first.EsdId);
     writeSymbol(LD, Layout);
   } else if (!GSection.isTextOwnedByED()) {
@@ -946,14 +905,17 @@ void GOFFObjectWriter::writeSectionSymbols(const MCSectionGOFF &GSection,
       Executability = GSym.value()->getExecutable();
       IsOSLinkage = GSym.value()->isOSLinkage();
     }
-    GOFFSymbol PR = createPRSymbol(GSection.getTextOwnerName(), SDEDSymbols.second.EsdId,
+    std::string ADAName = FileName + "#S";
+    GOFFSymbol PR = createPRSymbol(GSection.isStatic() ? ADAName : GSection.getTextOwnerName(),
+                                   SDEDSymbols.second.EsdId,
                                    GOFF::ESD_NS_Parts,
                                    Executability,
                                    GOFFSymbol::setGOFFAlignment(GSection.getAlign()),
                                    GOFF::ESD_BSC_Section,
                                    Layout.getSectionAddressSize(&GSection),
                                    GSection.getLoadBehavior(),
                                    IsOSLinkage ? GOFF::ESD_LT_OS : GOFF::ESD_LT_XPLink);
+    ADAPREsdId = PR.EsdId; 
     writeSymbol(PR, Layout);
     GOFFSection GoffSec = GOFFSection(PR.EsdId, SDEDSymbols.second.EsdId, SDEDSymbols.first.EsdId);
     SectionMap.insert(std::make_pair(&GSection, GoffSec));
@@ -1061,12 +1023,18 @@ uint64_t GOFFObjectWriter::writeObject(MCAssembler &Asm,
   writeHeader();
   writeSymbol(RootSD, Layout);
 
+  // The static and code sections must be written first because the symbols that make up the aforementioned sections
+  // are referenced by several other symbols/sections.
+  writeSectionSymbols(*getStaticSection(Asm), Asm, Layout);
+  writeSectionSymbols(*getCodeSection(Asm), Asm, Layout);
+
   for (MCSection &S : Asm) {
     auto &GSection = cast<MCSectionGOFF>(S);
     if (!(GSection.isCode() || GSection.isStatic()))
       writeSectionSymbols(GSection, Asm, Layout);
   }
 
+  /*
   // Process all MCSymbols and generate the ESD Record(s) for them.
   // Symbols that are aliases of other symbols need to be processed
   // at the end, after the symbols they alias are processed.
@@ -1088,6 +1056,7 @@ uint64_t GOFFObjectWriter::writeObject(MCAssembler &Asm,
         static_cast<GOFF::TXTRecordStyle>(MCGOFFSec.getTextStyle());
     writeText(&MCGOFFSec, CurrGSec.PEsdId, TextStyle, Asm, Layout);
   }
+  */
 
   writeEnd();
 
diff --git a/llvm/lib/MC/MCContext.cpp b/llvm/lib/MC/MCContext.cpp
@@ -656,7 +656,7 @@ MCSectionGOFF *MCContext::getGOFFSection(StringRef Section, SectionKind Kind,
                                          GOFF::ESDBindingAlgorithm BindAlgorithm,
                                          GOFF::ESDLoadingBehavior LoadBehavior,
                                          GOFF::ESDBindingScope BindingScope,
-                                         bool isRooted, MCSymbolGOFF *TextOwner) {
+                                         bool isRooted, const MCSymbolGOFF *TextOwner) {
   return getGOFFSection(Section, Kind, nullptr, nullptr, GOFF::GOFFSectionType::Other,
   TextStyle, BindAlgorithm, LoadBehavior, BindingScope, isRooted, TextOwner);
 }
@@ -669,7 +669,7 @@ MCSectionGOFF *MCContext::getGOFFSection(StringRef Section, SectionKind Kind,
                                          GOFF::ESDBindingAlgorithm BindAlgorithm,
                                          GOFF::ESDLoadingBehavior LoadBehavior,
                                          GOFF::ESDBindingScope BindingScope,
-                                         bool isRooted, MCSymbolGOFF *TextOwner) {
+                                         bool isRooted, const MCSymbolGOFF *TextOwner) {
   // Do the lookup. If we don't have a hit, return a new section.
   auto IterBool = GOFFUniquingMap.insert(std::make_pair(
       GOFFSectionKey{Section.str(), SectionType, (Parent != nullptr)},
diff --git a/llvm/lib/MC/MCObjectFileInfo.cpp b/llvm/lib/MC/MCObjectFileInfo.cpp
@@ -556,8 +556,7 @@ void MCObjectFileInfo::initGOFFMCObjectFileInfo(const Triple &T) {
                           MCConstantExpr::create(GOFF::SK_PPA1, *Ctx));
   PPA2Section =
       Ctx->getGOFFSection(".ppa2", SectionKind::getMetadata(), TextSection,
-                          MCConstantExpr::create(GOFF::SK_PPA2, *Ctx),
-                          GOFF::GOFFSectionType::PPA2Offset);
+                          MCConstantExpr::create(GOFF::SK_PPA2, *Ctx));
 
   PPA2ListSection =
       Ctx->getGOFFSection(".ppa2list", SectionKind::getData(), nullptr, nullptr,
