[GOFF] Emit symbols for functions.

llvm/include/llvm/MC/MCDirectives.h

@@ -48,6 +48,10 @@ enum MCSymbolAttr {
   MCSA_WeakDefAutoPrivate,      ///< .weak_def_can_be_hidden (MachO)
   MCSA_WeakAntiDep,             ///< .weak_anti_dep (COFF)
   MCSA_Memtag,                  ///< .memtag (ELF)
+  MCSA_Code,                    ///< symbol is code (GOFF)
+  MCSA_Data,                    ///< symbol is data (GOFF)
+  MCSA_OSLinkage,               ///< symbol uses OS linkage (GOFF)
+  MCSA_XPLinkage,               ///< symbol uses XP linkage (GOFF)
 };
 
 enum MCDataRegionType {

llvm/include/llvm/MC/MCGOFFAttributes.h

@@ -80,6 +80,15 @@ struct PRAttr {
   uint32_t SortKey = 0;
 };
 
+// Attributes for ER symbols.
+struct ERAttr {
+  GOFF::ESDExecutable Executable = GOFF::ESD_EXE_Unspecified;
+  GOFF::ESDBindingStrength BindingStrength = GOFF::ESD_BST_Strong;
+  GOFF::ESDLinkageType Linkage = GOFF::ESD_LT_XPLink;
+  GOFF::ESDAmode Amode;
+  GOFF::ESDBindingScope BindingScope = GOFF::ESD_BSC_Unspecified;
+};
+
 // Predefined GOFF class names.
 constexpr StringLiteral CLASS_CODE = "C_CODE64";
 constexpr StringLiteral CLASS_WSA = "C_WSA64";

llvm/include/llvm/MC/MCGOFFStreamer.h

@@ -14,6 +14,7 @@
 
 namespace llvm {
 class GOFFObjectWriter;
+class MCSymbolGOFF;
 
 class MCGOFFStreamer : public MCObjectStreamer {
 
@@ -28,11 +29,14 @@ class MCGOFFStreamer : public MCObjectStreamer {
 
   GOFFObjectWriter &getWriter();
 
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
-    return false;
-  }
+  void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         Align ByteAlignment) override {}
+
+  void emitExterns();
 };
 
 } // end namespace llvm

llvm/include/llvm/MC/MCSymbolGOFF.h

@@ -23,12 +23,24 @@ namespace llvm {
 
 class MCSymbolGOFF : public MCSymbol {
   // Associated data area of the section. Needs to be emitted first.
-  MCSectionGOFF *ADA;
+  MCSectionGOFF *ADA = nullptr;
+
+  // Owner of the symbol if symbol is an external reference. External references
+  // need a section, too, but adding them to a section would make the symbol
+  // defined.
+  MCSectionGOFF *Owner = nullptr;
 
   GOFF::LDAttr LDAttributes;
+  GOFF::ERAttr ERAttributes;
+
+  GOFF::ESDExecutable CodeData = GOFF::ESDExecutable::ESD_EXE_Unspecified;
+  GOFF::ESDLinkageType Linkage = GOFF::ESDLinkageType::ESD_LT_XPLink;
 
   enum SymbolFlags : uint16_t {
-    SF_LD = 0x01, // LD attributes are set.
+    SF_LD = 0x01,     // LD attributes are set.
+    SF_ER = 0x02,     // ER attributes are set.
+    SF_Hidden = 0x04, // Symbol is hidden, aka not exported.
+    SF_Weak = 0x08,   // Symbol is weak.
   };
 
 public:
@@ -39,14 +51,46 @@ class MCSymbolGOFF : public MCSymbol {
     modifyFlags(SF_LD, SF_LD);
     LDAttributes = Attr;
   }
-  GOFF::LDAttr getLDAttributes() const { return LDAttributes; }
+  const GOFF::LDAttr &getLDAttributes() const { return LDAttributes; }
+  GOFF::LDAttr &getLDAttributes() { return LDAttributes; }
   bool hasLDAttributes() const { return getFlags() & SF_LD; }
 
+  void setERAttributes(GOFF::ERAttr Attr) {
+    modifyFlags(SF_ER, SF_ER);
+    ERAttributes = Attr;
+  }
+  const GOFF::ERAttr &getERAttributes() const { return ERAttributes; }
+  GOFF::ERAttr &getERAttributes() { return ERAttributes; }
+  bool hasERAttributes() const { return getFlags() & SF_ER; }
+
   void setADA(MCSectionGOFF *AssociatedDataArea) {
     ADA = AssociatedDataArea;
     AssociatedDataArea->RequiresNonZeroLength = true;
   }
   MCSectionGOFF *getADA() const { return ADA; }
+
+  void setOwner(MCSectionGOFF *Owner) { this->Owner = Owner; }
+  MCSectionGOFF *getOwner() const { return Owner; }
+
+  bool isExternal() const { return IsExternal; }
+  void setExternal(bool Value) const { IsExternal = Value; }
+
+  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 setCodeData(GOFF::ESDExecutable Value) { CodeData = Value; }
+  GOFF::ESDExecutable getCodeData() const { return CodeData; }
+
+  void setLinkage(GOFF::ESDLinkageType Value) { Linkage = Value; }
+  GOFF::ESDLinkageType getLinkage() const { return Linkage; }
+
+  void initAttributes();
 };
 } // end namespace llvm
 

llvm/lib/MC/CMakeLists.txt

@@ -50,6 +50,7 @@ add_llvm_component_library(LLVMMC
   MCSubtargetInfo.cpp
   MCSymbol.cpp
   MCSymbolELF.cpp
+  MCSymbolGOFF.cpp
   MCSymbolXCOFF.cpp
   MCTargetOptions.cpp
   MCTargetOptionsCommandFlags.cpp

llvm/lib/MC/GOFFObjectWriter.cpp

@@ -266,6 +266,18 @@ class GOFFSymbol {
     BehavAttrs.setBindingScope(Attr.BindingScope);
     BehavAttrs.setAlignment(EDAttr.Alignment);
   }
+
+  GOFFSymbol(StringRef Name, uint32_t EsdID, uint32_t ParentEsdID,
+             const GOFF::ERAttr &Attr)
+      : Name(Name.data(), Name.size()), EsdId(EsdID), ParentEsdId(ParentEsdID),
+        SymbolType(GOFF::ESD_ST_ExternalReference),
+        NameSpace(GOFF::ESD_NS_NormalName) {
+    BehavAttrs.setExecutable(Attr.Executable);
+    BehavAttrs.setBindingStrength(Attr.BindingStrength);
+    BehavAttrs.setLinkageType(Attr.Linkage);
+    BehavAttrs.setAmode(Attr.Amode);
+    BehavAttrs.setBindingScope(Attr.BindingScope);
+  }
 };
 
 class GOFFWriter {
@@ -279,6 +291,7 @@ class GOFFWriter {
 
   void defineSectionSymbols(const MCSectionGOFF &Section);
   void defineLabel(const MCSymbolGOFF &Symbol);
+  void defineExtern(const MCSymbolGOFF &Symbol);
   void defineSymbols();
 
 public:
@@ -328,9 +341,16 @@ void GOFFWriter::defineLabel(const MCSymbolGOFF &Symbol) {
                 Section.getEDAttributes().NameSpace, Symbol.getLDAttributes());
   if (Symbol.getADA())
     LD.ADAEsdId = Symbol.getADA()->getOrdinal();
+  LD.Offset = Asm.getSymbolOffset(Symbol);
   writeSymbol(LD);
 }
 
+void GOFFWriter::defineExtern(const MCSymbolGOFF &Symbol) {
+  GOFFSymbol ER(Symbol.getName(), Symbol.getIndex(),
+                Symbol.getOwner()->getOrdinal(), Symbol.getERAttributes());
+  writeSymbol(ER);
+}
+
 void GOFFWriter::defineSymbols() {
   unsigned Ordinal = 0;
   // Process all sections.
@@ -348,6 +368,9 @@ void GOFFWriter::defineSymbols() {
     if (Symbol.hasLDAttributes()) {
       Symbol.setIndex(++Ordinal);
       defineLabel(Symbol);
+    } else if (Symbol.hasERAttributes()) {
+      Symbol.setIndex(++Ordinal);
+      defineExtern(Symbol);
     }
   }
 }

llvm/lib/MC/MCAsmStreamer.cpp

@@ -774,6 +774,11 @@ bool MCAsmStreamer::emitSymbolAttribute(MCSymbol *Symbol,
     // Assemblers currently do not support a .cold directive.
   case MCSA_Exported:
     // Non-AIX assemblers currently do not support exported visibility.
+  case MCSA_Code:
+  case MCSA_Data:
+  case MCSA_OSLinkage:
+  case MCSA_XPLinkage:
+    // Only for HLASM.
     return false;
   case MCSA_Memtag:
     OS << "\t.memtag\t";

llvm/lib/MC/MCELFStreamer.cpp

@@ -18,6 +18,7 @@
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
@@ -151,6 +152,10 @@ bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_IndirectSymbol:
   case MCSA_Exported:
   case MCSA_WeakAntiDep:
+  case MCSA_Code:
+  case MCSA_Data:
+  case MCSA_OSLinkage:
+  case MCSA_XPLinkage:
     return false;
 
   case MCSA_NoDeadStrip:

llvm/lib/MC/MCGOFFStreamer.cpp

@@ -11,11 +11,14 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCGOFFStreamer.h"
+#include "llvm/BinaryFormat/GOFF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCGOFFObjectWriter.h"
+#include "llvm/MC/MCSymbolGOFF.h"
 #include "llvm/MC/TargetRegistry.h"
 
 using namespace llvm;
@@ -37,6 +40,85 @@ void MCGOFFStreamer::changeSection(MCSection *Section, uint32_t Subsection) {
   }
 }
 
+void MCGOFFStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
+  MCObjectStreamer::emitLabel(Symbol, Loc);
+  static_cast<MCSymbolGOFF *>(Symbol)->initAttributes();
+}
+
+bool MCGOFFStreamer::emitSymbolAttribute(MCSymbol *Sym,
+                                         MCSymbolAttr Attribute) {
+  auto *Symbol = static_cast<MCSymbolGOFF *>(Sym);
+  switch (Attribute) {
+  case MCSA_Invalid:
+  case MCSA_Cold:
+  case MCSA_ELF_TypeFunction:
+  case MCSA_ELF_TypeIndFunction:
+  case MCSA_ELF_TypeObject:
+  case MCSA_ELF_TypeTLS:
+  case MCSA_ELF_TypeCommon:
+  case MCSA_ELF_TypeNoType:
+  case MCSA_ELF_TypeGnuUniqueObject:
+  case MCSA_LGlobal:
+  case MCSA_Extern:
+  case MCSA_Exported:
+  case MCSA_IndirectSymbol:
+  case MCSA_Internal:
+  case MCSA_LazyReference:
+  case MCSA_NoDeadStrip:
+  case MCSA_SymbolResolver:
+  case MCSA_AltEntry:
+  case MCSA_PrivateExtern:
+  case MCSA_Protected:
+  case MCSA_Reference:
+  case MCSA_WeakDefinition:
+  case MCSA_WeakDefAutoPrivate:
+  case MCSA_WeakAntiDep:
+  case MCSA_Memtag:
+    return false;
+
+  case MCSA_Code:
+    Symbol->setCodeData(GOFF::ESDExecutable::ESD_EXE_CODE);
+    break;
+  case MCSA_Data:
+    Symbol->setCodeData(GOFF::ESDExecutable::ESD_EXE_DATA);
+    break;
+  case MCSA_OSLinkage:
+    Symbol->setLinkage(GOFF::ESDLinkageType::ESD_LT_OS);
+    break;
+  case MCSA_XPLinkage:
+    Symbol->setLinkage(GOFF::ESDLinkageType::ESD_LT_XPLink);
+    break;
+  case MCSA_Global:
+    Symbol->setExternal(true);
+    break;
+  case MCSA_Local:
+    Symbol->setExternal(false);
+    break;
+  case MCSA_Weak:
+  case MCSA_WeakReference:
+    Symbol->setExternal(true);
+    Symbol->setWeak();
+    break;
+  case MCSA_Hidden:
+    Symbol->setHidden(true);
+    break;
+  }
+
+  return true;
+}
+
+void MCGOFFStreamer::emitExterns() {
+  for (auto &Symbol : getAssembler().symbols()) {
+    if (Symbol.isTemporary())
+      continue;
+    if (Symbol.isRegistered()) {
+      auto &Sym = static_cast<MCSymbolGOFF &>(const_cast<MCSymbol &>(Symbol));
+      Sym.setOwner(static_cast<MCSectionGOFF *>(getCurrentSection().first));
+      Sym.initAttributes();
+    }
+  }
+}
+
 MCStreamer *llvm::createGOFFStreamer(MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> &&MAB,
                                      std::unique_ptr<MCObjectWriter> &&OW,

llvm/lib/MC/MCMachOStreamer.cpp

@@ -299,6 +299,10 @@ bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
   case MCSA_Exported:
   case MCSA_Memtag:
   case MCSA_WeakAntiDep:
+  case MCSA_Code:
+  case MCSA_Data:
+  case MCSA_OSLinkage:
+  case MCSA_XPLinkage:
     return false;
 
   case MCSA_Global:

llvm/lib/MC/MCSymbolGOFF.cpp

@@ -0,0 +1,46 @@
+//===- MCSymbolGOFF.cpp - GOFF Symbol Representation ----------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCSymbolGOFF.h"
+#include "llvm/BinaryFormat/GOFF.h"
+#include "llvm/Support/ErrorHandling.h"
+
+using namespace llvm;
+
+void MCSymbolGOFF::initAttributes() {
+  // Temporary labels are not emitted into the object file.
+  if (isTemporary())
+    return;
+
+  // Do not initialize the attributes multiple times.
+  if (hasLDAttributes() || hasERAttributes())
+    return;
+
+  GOFF::ESDBindingScope BindingScope =
+      isExternal()
+          ? (isExported() ? GOFF::ESD_BSC_ImportExport : GOFF::ESD_BSC_Library)
+          : GOFF::ESD_BSC_Section;
+  GOFF::ESDBindingStrength BindingStrength =
+      isWeak() ? GOFF::ESDBindingStrength::ESD_BST_Weak
+               : GOFF::ESDBindingStrength::ESD_BST_Strong;
+
+  if (isDefined()) {
+    MCSectionGOFF &Section = static_cast<MCSectionGOFF &>(getSection());
+    if (Section.isED()) {
+      setLDAttributes(GOFF::LDAttr{false, CodeData, BindingStrength, Linkage,
+                                   GOFF::ESD_AMODE_64, BindingScope});
+    } else if (Section.isPR()) {
+      // For data symbols, the attributes are already determind in TLOFI.
+      // TODO Does it make sense to it to here?
+    } else
+      llvm_unreachable("Unexpected section type for label");
+  } else {
+    setERAttributes(GOFF::ERAttr{CodeData, BindingStrength, Linkage,
+                                 GOFF::ESD_AMODE_64, BindingScope});
+  }
+}