AMDGPU/SI: Emit constant arrays in the .hsrodata_readonly_agent section

[• tstellarAMD]

Summary

This is done only when target HSA.

[arsenm]

test/CodeGen/AMDGPU/hsa-globals.ll

8

Should there be tests with a variety of alignments?

[• tstellarAMD]

Rebase after changes to D13806

[• tstellarAMD]

test/CodeGen/AMDGPU/hsa-globals.ll

9

Maybe, I'm not sure exactly how the output would be different.

[arsenm]

LGTM

[• tstellarAMD]

Rebased on top of recent changes.

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

static bool isModuleLinkage(const GlobalValue *GV) {
   default: llvm_unreachable("unknown linkage type");
   }
 }
 
 void AMDGPUAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
 
   const Module *M = GV->getParent();
   if (TM.getTargetTriple().getOS() != Triple::AMDHSA ||
-      GV->isDeclaration() || AMDGPU::isReadOnlySegment(GV)) {
+      GV->isDeclaration()) {
     AsmPrinter::EmitGlobalVariable(GV);
     return;
   }
 
   // Group segment variables aren't emitted in HSA.
   if (AMDGPU::isGroupSegment(GV))
     return;
 

lib/Target/AMDGPU/AMDGPUHSATargetObjectFile.h

 #include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 
 class AMDGPUHSATargetObjectFile final : public TargetLoweringObjectFileELF {
 private:
   MCSection *DataGlobalAgentSection;
   MCSection *DataGlobalProgramSection;
+  MCSection *RodataReadonlyAgentSection;
 
   bool isAgentAllocationSection(const char *SectionName) const;
   bool isAgentAllocation(const GlobalValue *GV) const;
   bool isProgramAllocation(const GlobalValue *GV) const;
 
 public:
   void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
   MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
                                     Mangler &Mang,
                                     const TargetMachine &TM) const override;
 };
 
 } // end namespace llvm
 
 #endif

lib/Target/AMDGPU/AMDGPUHSATargetObjectFile.cpp

void AMDGPUHSATargetObjectFile::Initialize(MCContext &Ctx,
   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
   InitializeELF(TM.Options.UseInitArray);
 
   TextSection = AMDGPU::getHSATextSection(Ctx);
 
   DataGlobalAgentSection = AMDGPU::getHSADataGlobalAgentSection(Ctx);
   DataGlobalProgramSection = AMDGPU::getHSADataGlobalProgramSection(Ctx);
 
+  RodataReadonlyAgentSection = AMDGPU::getHSARodataReadonlyAgentSection(Ctx);
 }
 
 bool AMDGPUHSATargetObjectFile::isAgentAllocationSection(
     const char *SectionName) const {
   return cast<MCSectionELF>(DataGlobalAgentSection)
       ->getSectionName()
       .equals(SectionName);
 }
MCSection *AMDGPUHSATargetObjectFile::SelectSectionForGlobal(
   if (AMDGPU::isGlobalSegment(GV)) {
     if (isAgentAllocation(GV))
       return DataGlobalAgentSection;
 
     if (isProgramAllocation(GV))
       return DataGlobalProgramSection;
   }
 
+  if (Kind.isReadOnly() && AMDGPU::isReadOnlySegment(GV))
+    return RodataReadonlyAgentSection;
+
   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, Mang, TM);
 }

lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

private:
   bool ParseDirectiveAMDKernelCodeT();
   bool ParseSectionDirectiveHSAText();
   bool subtargetHasRegister(const MCRegisterInfo &MRI, unsigned RegNo) const;
   bool ParseDirectiveAMDGPUHsaKernel();
   bool ParseDirectiveAMDGPUHsaModuleGlobal();
   bool ParseDirectiveAMDGPUHsaProgramGlobal();
   bool ParseSectionDirectiveHSADataGlobalAgent();
   bool ParseSectionDirectiveHSADataGlobalProgram();
+  bool ParseSectionDirectiveHSARodataReadonlyAgent();
 
 public:
 public:
   enum AMDGPUMatchResultTy {
     Match_PreferE32 = FIRST_TARGET_MATCH_RESULT_TY
   };
 
   AMDGPUAsmParser(MCSubtargetInfo &STI, MCAsmParser &_Parser,

 }
 
 bool AMDGPUAsmParser::ParseSectionDirectiveHSADataGlobalProgram() {
   getParser().getStreamer().SwitchSection(
       AMDGPU::getHSADataGlobalProgramSection(getContext()));
   return false;
 }
 
+bool AMDGPUAsmParser::ParseSectionDirectiveHSARodataReadonlyAgent() {
+  getParser().getStreamer().SwitchSection(
+      AMDGPU::getHSARodataReadonlyAgentSection(getContext()));
+  return false;
+}
+
 bool AMDGPUAsmParser::ParseDirective(AsmToken DirectiveID) {
   StringRef IDVal = DirectiveID.getString();
 
   if (IDVal == ".hsa_code_object_version")
     return ParseDirectiveHSACodeObjectVersion();
 
   if (IDVal == ".hsa_code_object_isa")
     return ParseDirectiveHSACodeObjectISA();
if (IDVal == ".amdgpu_hsa_program_global")
     return ParseDirectiveAMDGPUHsaProgramGlobal();
 
   if (IDVal == ".hsadata_global_agent")
     return ParseSectionDirectiveHSADataGlobalAgent();
 
   if (IDVal == ".hsadata_global_program")
     return ParseSectionDirectiveHSADataGlobalProgram();
 
+  if (IDVal == ".hsarodata_readonly_agent")
+    return ParseSectionDirectiveHSARodataReadonlyAgent();
+
   return true;
 }
 
 bool AMDGPUAsmParser::subtargetHasRegister(const MCRegisterInfo &MRI,
                                            unsigned RegNo) const {
   if (!isVI())
     return true;
 

lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCAsmInfo.cpp

AMDGPUMCAsmInfo::AMDGPUMCAsmInfo(const Triple &TT) : MCAsmInfoELF() {
   WeakRefDirective = ".weakref\t";
   //===--- Dwarf Emission Directives -----------------------------------===//
   SupportsDebugInformation = true;
 }
 
 bool AMDGPUMCAsmInfo::shouldOmitSectionDirective(StringRef SectionName) const {
   return SectionName == ".hsatext" || SectionName == ".hsadata_global_agent" ||
          SectionName == ".hsadata_global_program" ||
+         SectionName == ".hsarodata_readonly_agent" ||
          MCAsmInfo::shouldOmitSectionDirective(SectionName);
 }

lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h

 void initDefaultAMDKernelCodeT(amd_kernel_code_t &Header,
                                const FeatureBitset &Features);
 MCSection *getHSATextSection(MCContext &Ctx);
 
 MCSection *getHSADataGlobalAgentSection(MCContext &Ctx);
 
 MCSection *getHSADataGlobalProgramSection(MCContext &Ctx);
 
+MCSection *getHSARodataReadonlyAgentSection(MCContext &Ctx);
+
 bool isGroupSegment(const GlobalValue *GV);
 bool isGlobalSegment(const GlobalValue *GV);
 bool isReadOnlySegment(const GlobalValue *GV);
 
 } // end namespace AMDGPU
 } // end namespace llvm
 
 #endif

lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp

 }
 
 MCSection *getHSADataGlobalProgramSection(MCContext &Ctx) {
   return  Ctx.getELFSection(".hsadata_global_program", ELF::SHT_PROGBITS,
                             ELF::SHF_ALLOC | ELF::SHF_WRITE |
                             ELF::SHF_AMDGPU_HSA_GLOBAL);
 }
 
+MCSection *getHSARodataReadonlyAgentSection(MCContext &Ctx) {
+  return Ctx.getELFSection(".hsarodata_readonly_agent", ELF::SHT_PROGBITS,
+                           ELF::SHF_ALLOC | ELF::SHF_AMDGPU_HSA_READONLY |
+                           ELF::SHF_AMDGPU_HSA_AGENT);
+}
+
 bool isGroupSegment(const GlobalValue *GV) {
   return GV->getType()->getAddressSpace() == AMDGPUAS::LOCAL_ADDRESS;
 }
 
 bool isGlobalSegment(const GlobalValue *GV) {
   return GV->getType()->getAddressSpace() == AMDGPUAS::GLOBAL_ADDRESS;
 }
 
 bool isReadOnlySegment(const GlobalValue *GV) {
   return GV->getType()->getAddressSpace() == AMDGPUAS::CONSTANT_ADDRESS;
 }
 
 } // End namespace AMDGPU
 } // End namespace llvm

test/CodeGen/AMDGPU/hsa-globals.ll

 ; RUN: llc < %s -mtriple=amdgcn--amdhsa -mcpu=kaveri | FileCheck --check-prefix=ASM %s
 ; RUN: llc < %s -mtriple=amdgcn--amdhsa -mcpu=kaveri | llvm-mc -filetype=obj -triple amdgcn--amdhsa -mcpu=kaveri | llvm-readobj -symbols -s | FileCheck %s --check-prefix=ELF
 
 @internal_global_program = internal addrspace(1) global i32 0
 @common_global_program = common addrspace(1) global i32 0
 @external_global_program = addrspace(1) global i32 0
 
 @internal_global_agent = internal addrspace(1) global i32 0, section ".hsadata_global_agent"
 @common_global_agent = common addrspace(1) global i32 0, section ".hsadata_global_agent"
 @external_global_agent = addrspace(1) global i32 0, section ".hsadata_global_agent"
 
+@internal_readonly = internal unnamed_addr addrspace(2) constant i32 0
+@external_readonly = unnamed_addr addrspace(2) constant i32 0
+
 define void @test() {
   ret void
 }
 
 ; ASM: .amdgpu_hsa_module_global internal_global
 ; ASM: .hsadata_global_program
 ; ASM: internal_global_program:
 ; ASM: .long 0

 ; ASM: common_global_agent:
 ; ASM: .long 0
 
 ; ASM: .amdgpu_hsa_program_global external_global
 ; ASM: .hsadata_global_agent
 ; ASM: external_global_agent:
 ; ASM: .long 0
 
+; ASM: .amdgpu_hsa_module_global internal_readonly
+; ASM: .hsarodata_readonly_agent
+; ASM: internal_readonly:
+; ASM: .long 0
+
+; ASM: .amdgpu_hsa_program_global external_readonly
+; ASM: .hsarodata_readonly_agent
+; ASM: external_readonly:
+; ASM: .long 0
+
 ; ELF: Section {
 ; ELF: Name: .hsadata_global_program
 ; ELF: Type: SHT_PROGBITS (0x1)
 ; ELF: Flags [ (0x100003)
 ; ELF: SHF_ALLOC (0x2)
 ; ELF: SHF_AMDGPU_HSA_GLOBAL (0x100000)
 ; ELF: SHF_WRITE (0x1)
 ; ELF: ]
 ; ELF: }
 
 ; ELF: Section {
 ; ELF: Name: .hsadata_global_agent
 ; ELF: Type: SHT_PROGBITS (0x1)
 ; ELF: Flags [ (0x900003)
 ; ELF: SHF_ALLOC (0x2)
 ; ELF: SHF_AMDGPU_HSA_AGENT (0x800000)
 ; ELF: SHF_AMDGPU_HSA_GLOBAL (0x100000)
 ; ELF: SHF_WRITE (0x1)
 ; ELF: ]
 ; ELF: }
 
+; ELF: Section {
+; ELF: Name: .hsarodata_readonly_agent
+; ELF: Type: SHT_PROGBITS (0x1)
+; ELF: Flags [ (0xA00002)
+; ELF: SHF_ALLOC (0x2)
+; ELF: SHF_AMDGPU_HSA_AGENT (0x800000)
+; ELF: SHF_AMDGPU_HSA_READONLY (0x200000)
+; ELF: ]
+
 ; ELF: Symbol {
 ; ELF: Name: common_global_agent
 ; ELF: Binding: Local
 ; ELF: Section: .hsadata_global_agent
 ; ELF: }
 
 ; ELF: Symbol {
 ; ELF: Name: common_global_program

 ; ELF: Symbol {
 ; ELF: Name: internal_global_program
 ; ELF: Binding: Local
 ; ELF: Type: Object
 ; ELF: Section: .hsadata_global_program
 ; ELF: }
 
 ; ELF: Symbol {
+; ELF: Name: internal_readonly
+; ELF: Binding: Local
+; ELF: Type: Object
+; ELF: Section: .hsarodata_readonly_agent
+; ELF: }
+
+; ELF: Symbol {
 ; ELF: Name: external_global_agent
 ; ELF: Binding: Global
 ; ELF: Type: Object
 ; ELF: Section: .hsadata_global_agent
 ; ELF: }
 
 ; ELF: Symbol {
 ; ELF: Name: external_global_program
 ; ELF: Binding: Global
 ; ELF: Type: Object
 ; ELF: Section: .hsadata_global_program
 ; ELF: }
+
+; ELF: Symbol {
+; ELF: Name: external_readonly
+; ELF: Binding: Global
+; ELF: Type: Object
+; ELF: Section: .hsarodata_readonly_agent
+; ELF: }