Put large common blocks into .lbss for the medium and large code models

For the medium and large code models on x86-64, the bss is split into two parts,
.bss for regular sized data, and .lbss for data larger than that specified by
-large-data-threshold (for the medium code model).  This change tries to mimick
what gcc does for the medium and large code models for Fortran COMMON blocks:

program test
  implicit integer  (i-n)
  implicit real*8   (a-h, o-z)
  parameter (n1=77777, n2=77777)
  common  v2(n1,n2)
  common /ccc/ v6
  v6 = 1
  v2(6777,6777) = 2
  write (*,*) v6, v2(6777, 6777)
end program test

Currently, we generate:

0000000000000008       O *COM*  0000000000000008 ccc_
0000000b44834508       O *COM*  0000000000000008 __BLNK

and ld and lld both fail to link with -mcmodel=medium.

/usr/bin/ld: failed to convert GOTPCREL relocation; relink with --no-relax

or

ld.lld: error: /usr/lib/gcc/x86_64-redhat-linux/11/crtbeginS.o:(.text+0x76): relocation R_X86_64_PC32 out of range: 48394103061 is not in [-2147483648, 2147483647]; references section '.bss'

With this change,  __BLNK is marked as LARGE_COMMON (SHN_AMD64_LCOMMON),
and ends up in .lbss.

*.o:
Sections:
...
1 .lbss         00000000  0000000000000000  0000000000000000  000000fb  2**0
                ALLOC
...
SYMBOL TABLE:
0000000000000008       O *COM*  0000000000000008 ccc_
0000000b44834508       O LARGE_COMMON   0000000000000008 __BLNK__

a.out:
Sections:
...
25 .bss          00000009  0000000000003cf0  0000000000003cf0  00000cf0  2**3
                 ALLOC
26 .lbss         b44834508  0000000000003d00  0000000000003d00  00000cf0  2**3
                 ALLOC

SYMBOL TABLE:
0000000000003cf0 g     O .bss   0000000000000008              ccc_
0000000000003d00 g     O .lbss  0000000b44834508              __BLNK__

In the assembly, this will appear as:

.section        .lbss,"awl",@nobits
.type   __BLNK__,@object
.largecomm      __BLNK__,48394093832,8
.type   ccc_,@object
.comm   ccc_,8,8

For the large code model, all common blocks will end up in lbss.

Previously, the above example wouldn't link statically with GNU ld.

The change also includes support for parsing the largecomm directive.
There will be a PR for the chages to lld to handle the SHN_AMD64_LCOMMON
section.

Author: ssijaric-nv

llvm/include/llvm/BinaryFormat/ELF.h

@@ -589,6 +589,11 @@ enum {
   SHN_MIPS_SUNDEFINED = 0xff04 // Undefined symbols for global data area
 };
 
+// x86-64 speciifc section index
+enum {
+  SHN_AMD64_LCOMMON = 0xff02, // Large FORTRAN COMMON variables
+};
+
 // ELF Relocation types for Mips
 enum {
 #include "ELFRelocs/Mips.def"

llvm/include/llvm/MC/MCELFStreamer.h

@@ -56,6 +56,8 @@ class MCELFStreamer : public MCObjectStreamer {
   bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         Align ByteAlignment) override;
+  void emitLargeCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+                             Align ByteAlignment) override;
 
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
   void emitELFSymverDirective(const MCSymbol *OriginalSym, StringRef Name,

llvm/include/llvm/MC/MCStreamer.h

@@ -677,6 +677,14 @@ class LLVM_ABI MCStreamer {
   virtual void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                 Align ByteAlignment) = 0;
 
+  /// Emit a large common (.largecomm) symbol.
+  ///
+  /// \param Symbol - The common symbol to emit.
+  /// \param Size - The size of the common symbol.
+  /// \param ByteAlignment - The alignment of the common symbol in bytes.
+  virtual void emitLargeCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+                                     Align ByteAlignment);
+
   /// Emit a local common (.lcomm) symbol.
   ///
   /// \param Symbol - The common symbol to emit.

llvm/include/llvm/MC/MCSymbolELF.h

@@ -17,6 +17,7 @@ class MCSymbolELF : public MCSymbol {
   /// An expression describing how to calculate the size of a symbol. If a
   /// symbol has no size this field will be NULL.
   const MCExpr *SymbolSize = nullptr;
+  bool IsLargeCommon = false;
 
 public:
   MCSymbolELF(const MCSymbolTableEntry *Name, bool isTemporary)
@@ -48,6 +49,9 @@ class MCSymbolELF : public MCSymbol {
   void setMemtag(bool Tagged);
   bool isMemtag() const;
 
+  bool isLargeCommon() const { return IsLargeCommon; }
+  void setIsLargeCommon(bool V) { IsLargeCommon = V; }
+
 private:
   void setIsBindingSet() const;
 };

llvm/include/llvm/Object/ELFTypes.h

@@ -252,6 +252,8 @@ struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> {
     return getType() == ELF::STT_COMMON || st_shndx == ELF::SHN_COMMON;
   }
 
+  bool isLargeCommon() const { return st_shndx == ELF::SHN_AMD64_LCOMMON; }
+
   bool isDefined() const { return !isUndefined(); }
 
   bool isProcessorSpecific() const {

llvm/include/llvm/Target/TargetLoweringObjectFile.h

@@ -305,6 +305,12 @@ class LLVM_ABI TargetLoweringObjectFile : public MCObjectFileInfo {
     return nullptr;
   }
 
+  virtual MCSection *LargeSectionForCommon(const GlobalObject *GO,
+                                           SectionKind Kind,
+                                           const TargetMachine &TM) const {
+    return nullptr;
+  }
+
 protected:
   virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
                                             SectionKind Kind,

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

@@ -782,11 +782,18 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
     OutContext.reportError(SMLoc(), "symbol '" + Twine(GVSym->getName()) +
                                         "' is already defined");
 
+  SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
+
+  // Place the large common variables in the .lbss section for the medium and
+  // large code models on x86_64. (AMD64 ABI, 9.2.5 COMMON blocks)
+  MCSection *largeCommonSec =
+      getObjFileLowering().LargeSectionForCommon(GV, GVKind, TM);
+  if (largeCommonSec)
+    OutStreamer->switchSection(largeCommonSec);
+
   if (MAI->hasDotTypeDotSizeDirective())
     OutStreamer->emitSymbolAttribute(EmittedSym, MCSA_ELF_TypeObject);
 
-  SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
-
   const DataLayout &DL = GV->getDataLayout();
   uint64_t Size = DL.getTypeAllocSize(GV->getValueType());
 
@@ -802,10 +809,12 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   if (GVKind.isCommon()) {
     if (Size == 0) Size = 1;   // .comm Foo, 0 is undefined, avoid it.
     // .comm _foo, 42, 4
-    OutStreamer->emitCommonSymbol(GVSym, Size, Alignment);
+    if (largeCommonSec)
+      OutStreamer->emitLargeCommonSymbol(GVSym, Size, Alignment);
+    else
+      OutStreamer->emitCommonSymbol(GVSym, Size, Alignment);
     return;
   }
-
   // Determine to which section this global should be emitted.
   MCSection *TheSection = getObjFileLowering().SectionForGlobal(GV, GVKind, TM);
 

llvm/lib/MC/ELFObjectWriter.cpp

@@ -27,6 +27,7 @@
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
+#include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionELF.h"
@@ -544,7 +545,10 @@ void ELFWriter::computeSymbolTable(const RevGroupMapTy &RevGroupMap) {
       auto Shndx = Symbol.getIndex();
       if (!Shndx) {
         assert(!Local);
-        Shndx = ELF::SHN_COMMON;
+        if (Symbol.isLargeCommon())
+          Shndx = ELF::SHN_AMD64_LCOMMON;
+        else
+          Shndx = ELF::SHN_COMMON;
       }
       MSD.SectionIndex = Shndx;
     } else if (Symbol.isUndefined()) {

llvm/lib/MC/MCAsmStreamer.cpp

@@ -228,7 +228,8 @@ class MCAsmStreamer final : public MCStreamer {
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         Align ByteAlignment) override;
-
+  void emitLargeCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+                             Align ByteAlignment) override;
   /// Emit a local common (.lcomm) symbol.
   ///
   /// @param Symbol - The common symbol to emit.
@@ -1075,6 +1076,19 @@ void MCAsmStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
   }
 }
 
+void MCAsmStreamer::emitLargeCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+                                          Align ByteAlignment) {
+  OS << "\t.largecomm\t";
+  Symbol->print(OS, MAI);
+  OS << ',' << Size;
+
+  if (MAI->getCOMMDirectiveAlignmentIsInBytes())
+    OS << ',' << ByteAlignment.value();
+  else
+    OS << ',' << Log2(ByteAlignment);
+  EmitEOL();
+}
+
 void MCAsmStreamer::emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                           Align ByteAlign) {
   OS << "\t.lcomm\t";

llvm/lib/MC/MCELFStreamer.cpp

@@ -244,6 +244,23 @@ bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   return true;
 }
 
+void MCELFStreamer::emitLargeCommonSymbol(MCSymbol *S, uint64_t Size,
+                                          Align ByteAlignment) {
+  auto *Symbol = static_cast<MCSymbolELF *>(S);
+  getAssembler().registerSymbol(*Symbol);
+
+  if (!Symbol->isBindingSet())
+    Symbol->setBinding(ELF::STB_GLOBAL);
+
+  Symbol->setType(ELF::STT_OBJECT);
+
+  if (Symbol->declareCommon(Size, ByteAlignment))
+    report_fatal_error(Twine("Symbol: ") + Symbol->getName() +
+                       " redeclared as different type");
+  Symbol->setIsLargeCommon(true);
+  Symbol->setSize(MCConstantExpr::create(Size, getContext()));
+}
+
 void MCELFStreamer::emitCommonSymbol(MCSymbol *S, uint64_t Size,
                                      Align ByteAlignment) {
   auto *Symbol = static_cast<MCSymbolELF *>(S);