[X86] Use "l" prefix for data sections under medium/large code model

[aeubanks]

Summary

And also set the SHF_X86_64_LARGE section flag.

gcc only uses the "l" prefix and SHF_X86_64_LARGE in the medium code model for data larger than -mlarge-data-threshold. But it seems more consistent to use it in the large code model as well in case separate parts of the binary aren't compiled with the large code model and also have a .data/.bss/.rodata section.

[jyknight]

1. Largedata is currently x86-only, and so an alternative would be to move some of this into llvm/lib/Target/X86/X86TargetObjectFile.cpp. There is code very much like that in e.g. llvm/lib/Target/RISCV/RISCVTargetObjectFile.cpp in order to select the "small data/bss" sections (riscv "small data" is not really the same thing -- it's for placing some data within 12-bit offsets from _global_pointer in the main executable, so that the linker can delete the load of the upper bits by relying on GP already being loaded) . However, I think that large-data sections is a somewhat generic concept which could be used on other architectures in the same way (e.g. it seems like it could be implemented about the same way and be just as useful for aarch64). So probably implementing it generically is OK.

2. -mcmodel=large on x86 will need more work for it to be interoperable in the same way that -mcmodel=medium is intended to be. Since it's supposed to allow arbitrarily-large CODE as well, we'd need to also place "large code" into large-code sections, so that you don't break relocations from small-code to small-data (ro or rw), by sticking large-code in between. As such -- until that's going happen, which I think needs a discussion on ABI lists -- I'd like to not change the behavior of -mcmodel=large yet.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

631

This is fine as you have it in the compiler, but I'll just note that we cannot really do RELRO for .ldata.rel.ro sections in the linker, because today's program loaders only permit a single GNU_RELRO segment -- so .ldata.rel.ro has to be treated just like .ldata in the linker -- and thus stay as RW during program execution.

860

(Assuming we keep all this in the generic code) This should be abstracted so that it can work for !X86 in the future. Or, at least assert(getTargetTriple().getArch() == Triple::x86_64) in this block.

[aeubanks]

address comments

[MaskRay]

For what we want to do with -mcmodel=large, I have https://groups.google.com/g/x86-64-abi/c/jnQdJeabxiU and CCed some gcc/binutils folks

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

653–656

Use bool IsLarge = ... && ... or avoid the used-once variable.

858

Use &&

2177

The canonical spelling liked by both clang-format and clang-tidy is /*IsLarge=*/false (no space).

llvm/lib/Target/TargetMachine.cpp

47

return getCodeModel() == CodeModel::Medium

llvm/test/CodeGen/X86/code-model-elf-sections.ll

4

It will be useful to test fdata-sections

[aeubanks]

address comments

[aeubanks]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

653–656

the reason for this and the other style choices is that D149288 (which I'll submit alongside this patch) will expand upon these

[MaskRay]

Looks great! According to https://groups.google.com/g/x86-64-abi/c/jnQdJeabxiU , -mcmodel=large sections should be able to use .ldata as well, even though GCC hasn't made the change yet.

llvm/test/CodeGen/X86/code-model-elf-sections.ll

16

Consider llvm-readelf -S. The tabular output is easier to read.

[aeubanks]

use llvm-readelf instead of llvm-readobj

[aeubanks]

update test

llvm/include/llvm/Target/TargetMachine.h

public:
 
   /// Returns the code model. The choices are small, kernel, medium, large, and
   /// target default.
   CodeModel::Model getCodeModel() const { return CMModel; }
 
   /// Set the code model.
   void setCodeModel(CodeModel::Model CM) { CMModel = CM; }
 
+  bool isLargeData() const;
+
   bool isPositionIndependent() const;
 
   bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
 
   /// Returns true if this target uses emulated TLS.
   bool useEmulatedTLS() const;
 
   /// Returns the TLS model which should be used for the given global variable.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

else {
     assert(!Kind.isMergeableCString() && "unknown string width");
     assert(!Kind.isMergeableConst() && "unknown data width");
     return 0;
   }
 }
 
 /// Return the section prefix name used by options FunctionsSections and
 /// DataSections.
-static StringRef getSectionPrefixForGlobal(SectionKind Kind) {
+static StringRef getSectionPrefixForGlobal(SectionKind Kind, bool IsLarge) {
   if (Kind.isText())
     return ".text";
   if (Kind.isReadOnly())
-    return ".rodata";
+    return IsLarge ? ".lrodata" : ".rodata";
   if (Kind.isBSS())
-    return ".bss";
+    return IsLarge ? ".lbss" : ".bss";
   if (Kind.isThreadData())
     return ".tdata";
   if (Kind.isThreadBSS())
     return ".tbss";
   if (Kind.isData())
-    return ".data";
+    return IsLarge ? ".ldata" : ".data";
   if (Kind.isReadOnlyWithRel())
-    return ".data.rel.ro";
+    return IsLarge ? ".ldata.rel.ro" : ".data.rel.ro";
   llvm_unreachable("Unknown section kind");
 }
 
 static SmallString<128>
 getELFSectionNameForGlobal(const GlobalObject *GO, SectionKind Kind,
                            Mangler &Mang, const TargetMachine &TM,
                            unsigned EntrySize, bool UniqueSectionName) {
   SmallString<128> Name;
   if (Kind.isMergeableCString()) {
     // We also need alignment here.
     // FIXME: this is getting the alignment of the character, not the
     // alignment of the global!
     Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
         cast<GlobalVariable>(GO));
 
     std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
     Name = SizeSpec + utostr(Alignment.value());
   } else if (Kind.isMergeableConst()) {
     Name = ".rodata.cst";
     Name += utostr(EntrySize);
   } else {
-    Name = getSectionPrefixForGlobal(Kind);
+    bool IsLarge = false;
+    if (isa<GlobalVariable>(GO))
+      IsLarge = TM.isLargeData();
+    Name = getSectionPrefixForGlobal(Kind, IsLarge);
   }
 
   bool HasPrefix = false;
   if (const auto *F = dyn_cast<Function>(GO)) {
     if (std::optional<StringRef> Prefix = F->getSectionPrefix()) {
       raw_svector_ostream(Name) << '.' << *Prefix;
       HasPrefix = true;
     }
static MCSectionELF *selectELFSectionForGlobal(
 
   StringRef Group = "";
   bool IsComdat = false;
   if (const Comdat *C = getELFComdat(GO)) {
     Flags |= ELF::SHF_GROUP;
     Group = C->getName();
     IsComdat = C->getSelectionKind() == Comdat::Any;
   }
+  if (isa<GlobalVariable>(GO)) {
+    if (TM.isLargeData()) {
+      assert(TM.getTargetTriple().getArch() == Triple::x86_64);
+      Flags |= ELF::SHF_X86_64_LARGE;
+    }
+  }
 
   // Get the section entry size based on the kind.
   unsigned EntrySize = getEntrySizeForKind(Kind);
 
   bool UniqueSectionName = false;
   unsigned UniqueID = MCContext::GenericSectionID;
   if (EmitUniqueSection) {
     if (TM.getUniqueSectionNames()) {
static MCSectionWasm *selectWasmSectionForGlobal(
     MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
     const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
   StringRef Group = "";
   if (const Comdat *C = getWasmComdat(GO)) {
     Group = C->getName();
   }
 
   bool UniqueSectionNames = TM.getUniqueSectionNames();
-  SmallString<128> Name = getSectionPrefixForGlobal(Kind);
+  SmallString<128> Name = getSectionPrefixForGlobal(Kind, /*IsLarge=*/false);
 
   if (const auto *F = dyn_cast<Function>(GO)) {
     const auto &OptionalPrefix = F->getSectionPrefix();
     if (OptionalPrefix)
       raw_svector_ostream(Name) << '.' << *OptionalPrefix;
   }
 
   if (EmitUniqueSection && UniqueSectionNames) {

llvm/lib/Target/TargetMachine.cpp

 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/CodeGen.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 using namespace llvm;
 
 //---------------------------------------------------------------------------
 // TargetMachine Class
 //
 
 TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString,
                              const Triple &TT, StringRef CPU, StringRef FS,
                              const TargetOptions &Options)
     : TheTarget(T), DL(DataLayoutString), TargetTriple(TT),
       TargetCPU(std::string(CPU)), TargetFS(std::string(FS)), AsmInfo(nullptr),
       MRI(nullptr), MII(nullptr), STI(nullptr), RequireStructuredCFG(false),
       O0WantsFastISel(false), DefaultOptions(Options), Options(Options) {}
 
 TargetMachine::~TargetMachine() = default;
 
+bool TargetMachine::isLargeData() const {
+  if (getTargetTriple().getArch() != Triple::x86_64)
+    return false;
+  // Large data under the large code model still needs to be thought about, so
+  // restrict this to medium.
+  if (getCodeModel() != CodeModel::Medium)
+    return false;
+  return true;
+}
+
 bool TargetMachine::isPositionIndependent() const {
   return getRelocationModel() == Reloc::PIC_;
 }
 
 /// Reset the target options based on the function's attributes.
 /// setFunctionAttributes should have made the raw attribute value consistent
 /// with the command line flag if used.
 //

llvm/test/CodeGen/X86/code-model-elf-sections.ll

+; RUN: llc < %s -relocation-model=pic -filetype=obj -code-model=small -o %t
+; RUN: llvm-readelf -S %t | FileCheck %s --check-prefix=SMALL
+; RUN: llc < %s -relocation-model=pic -filetype=obj -code-model=medium -o %t
+; RUN: llvm-readelf -S %t | FileCheck %s --check-prefix=LARGE
+; RUN: llc < %s -relocation-model=pic -filetype=obj -code-model=large -o %t
+; RUN: llvm-readelf -S %t | FileCheck %s --check-prefix=SMALL
+
+; RUN: llc < %s -relocation-model=pic -filetype=obj -code-model=small -data-sections -o %t
+; RUN: llvm-readelf -S %t | FileCheck %s --check-prefix=SMALL-DS
+; RUN: llc < %s -relocation-model=pic -filetype=obj -code-model=medium -data-sections -o %t
+; RUN: llvm-readelf -S %t | FileCheck %s --check-prefix=LARGE-DS
+; RUN: llc < %s -relocation-model=pic -filetype=obj -code-model=large -data-sections -o %t
+; RUN: llvm-readelf -S %t | FileCheck %s --check-prefix=SMALL-DS
+
+; SMALL: .data {{.*}} WA {{.*}}
+; SMALL: .bss {{.*}} WA {{.*}}
+; SMALL: .rodata {{.*}} A {{.*}}
+; SMALL: .data.rel.ro {{.*}} WA {{.*}}
+
+; SMALL-DS: .data.data {{.*}} WA {{.*}}
+; SMALL-DS: .bss.bss {{.*}} WA {{.*}}
+; SMALL-DS: .rodata.rodata {{.*}} A {{.*}}
+; SMALL-DS: .data.rel.ro.relro {{.*}} WA {{.*}}
+
+; LARGE: .ldata {{.*}} WAl {{.*}}
+; LARGE: .lbss {{.*}} WAl {{.*}}
+; LARGE: .lrodata {{.*}} Al {{.*}}
+; LARGE: .ldata.rel.ro {{.*}} WAl {{.*}}
+
+; LARGE-DS: .ldata.data {{.*}} WAl {{.*}}
+; LARGE-DS: .lbss.bss {{.*}} WAl {{.*}}
+; LARGE-DS: .lrodata.rodata {{.*}} Al {{.*}}
+; LARGE-DS: .ldata.rel.ro.relro {{.*}} WAl {{.*}}
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--linux"
+
+@data = internal global [10 x i64] [i64 1, i64 2, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0]
+@bss = internal global [10 x i64] zeroinitializer
+@rodata = internal constant [10 x i64] zeroinitializer
+@relro = internal constant [10 x ptr] [ptr @func, ptr @func, ptr @func, ptr @func, ptr @func, ptr @func, ptr @func, ptr @func, ptr @func, ptr @func]
+
+declare void @func()