Add HLASM output and external references

Adds HLASM output and tests for it, per reviewer comment.
Also adds external references, because it fits very well
into the implementation.

Author: redstar

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)
+
+  // Attributes specific for HLASM.
+  MCSA_Code,                    ///< symbol is code (GOFF)
+  MCSA_Data,                    ///< symbol is data (GOFF)
 };
 
 enum MCDataRegionType {

llvm/include/llvm/MC/MCGOFFAttributes.h

@@ -80,6 +80,14 @@ 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::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 {
 
@@ -34,6 +35,8 @@ class MCGOFFStreamer : public MCObjectStreamer {
 
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         Align ByteAlignment) override {}
+
+  void emitExterns();
 };
 
 } // end namespace llvm

llvm/include/llvm/MC/MCSymbolGOFF.h

@@ -23,13 +23,21 @@ 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;
 
   enum SymbolFlags : uint16_t {
     SF_LD = 0x01,     // LD attributes are set.
-                      // Leave place for EX attributes.
+    SF_ER = 0x02,     // ER attributes are set.
     SF_Hidden = 0x04, // Symbol is hidden, aka not exported.
     SF_Weak = 0x08,   // Symbol is weak.
   };
@@ -46,12 +54,25 @@ class MCSymbolGOFF : public MCSymbol {
   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; }
 
@@ -64,6 +85,9 @@ class MCSymbolGOFF : public MCSymbol {
   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 initAttributes();
 };
 } // end namespace llvm

llvm/lib/MC/GOFFObjectWriter.cpp

@@ -266,6 +266,17 @@ 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.setBindingScope(Attr.BindingScope);
+  }
 };
 
 class GOFFWriter {
@@ -279,6 +290,7 @@ class GOFFWriter {
 
   void defineSectionSymbols(const MCSectionGOFF &Section);
   void defineLabel(const MCSymbolGOFF &Symbol);
+  void defineExtern(const MCSymbolGOFF &Symbol);
   void defineSymbols();
 
 public:
@@ -332,6 +344,12 @@ void GOFFWriter::defineLabel(const MCSymbolGOFF &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.
@@ -349,6 +367,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,9 @@ 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:
+    // Only for HLASM.
     return false;
   case MCSA_Memtag:
     OS << "\t.memtag\t";

llvm/lib/MC/MCELFStreamer.cpp

@@ -151,6 +151,8 @@ bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_IndirectSymbol:
   case MCSA_Exported:
   case MCSA_WeakAntiDep:
+  case MCSA_Code:
+  case MCSA_Data:
     return false;
 
   case MCSA_NoDeadStrip:

llvm/lib/MC/MCGOFFStreamer.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #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"
@@ -75,6 +76,12 @@ bool MCGOFFStreamer::emitSymbolAttribute(MCSymbol *Sym,
   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_Global:
     Symbol->setExternal(true);
     break;
@@ -94,6 +101,18 @@ bool MCGOFFStreamer::emitSymbolAttribute(MCSymbol *Sym,
   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,8 @@ bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
   case MCSA_Exported:
   case MCSA_Memtag:
   case MCSA_WeakAntiDep:
+  case MCSA_Code:
+  case MCSA_Data:
     return false;
 
   case MCSA_Global:

llvm/lib/MC/MCSymbolGOFF.cpp

@@ -13,27 +13,35 @@
 using namespace llvm;
 
 void MCSymbolGOFF::initAttributes() {
-  if (hasLDAttributes())
+  // 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());
-    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 (Section.isED()) {
-      setLDAttributes(GOFF::LDAttr{false, GOFF::ESD_EXE_CODE, BindingStrength,
+      setLDAttributes(GOFF::LDAttr{false, CodeData, BindingStrength,
                                    GOFF::ESD_LT_XPLink, 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,
+                                 GOFF::ESD_LT_XPLink, BindingScope});
   }
-  // TODO Handle external symbol.
 }