AMDGPU/SI: Correctly emit program global variables when targeting HSA

[arsenm]

LGTM

[• tstellarAMD]

Fixing handling of linkage and allocation types

[arsenm]

lib/Target/AMDGPU/AMDGPUHSATargetObjectFile.cpp

52–56

The isAgentAllocation vs. isProgramAllocation can be moved under a single isGlobalSegment

[• tstellarAMD]

Address review comment.

[arsenm]

LGTM

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

void AMDGPUAsmPrinter::EmitFunctionEntryLabel() {
 
   AsmPrinter::EmitFunctionEntryLabel();
 }
 
 void AMDGPUAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
 
   const Module *M = GV->getParent();
   if (Triple(M->getTargetTriple()).getOS() != Triple::AMDHSA ||
-      (!GV->hasCommonLinkage() && !GV->hasInternalLinkage())) {
+      GV->isDeclaration() ||
+      (!GV->hasCommonLinkage() && !GV->hasInternalLinkage() &&
+       !GV->hasExternalLinkage())) {
     AsmPrinter::EmitGlobalVariable(GV);
     return;
   }
 
   AMDGPUTargetStreamer *TS =
       static_cast<AMDGPUTargetStreamer *>(OutStreamer->getTargetStreamer());
+  if (GV->hasExternalLinkage()) {
+    TS->EmitAMDGPUHsaProgramGlobal(GV->getName());
+  } else {
     TS->EmitAMDGPUHsaModuleGlobal(GV->getName());
+  }
 
   const DataLayout &DL = getDataLayout();
   OutStreamer->PushSection();
   OutStreamer->SwitchSection(
       getObjFileLowering().SectionForGlobal(GV, *Mang, TM));
   MCSymbol *GVSym = getSymbol(GV);
   const Constant *C = GV->getInitializer();
   OutStreamer->EmitLabel(GVSym);

lib/Target/AMDGPU/AMDGPUHSATargetObjectFile.h

 #include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 
 class AMDGPUHSATargetObjectFile final : public TargetLoweringObjectFileELF {
 private:
   MCSection *DataGlobalAgentSection;
   MCSection *RodataReadonlyAgentSection;
+  MCSection *DataGlobalProgramSection;
 
 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,
 
   DataGlobalAgentSection = AMDGPU::getHSADataGlobalAgentSection(Ctx);
 
   RodataReadonlyAgentSection = Ctx.getELFSection(".hsarodata_readonly_agent",
                                                  ELF::SHT_PROGBITS,
                                                  ELF::SHF_ALLOC |
                                                  ELF::SHF_AMDGPU_HSA_READONLY |
                                                  ELF::SHF_AMDGPU_HSA_AGENT);
+
+  DataGlobalProgramSection = Ctx.getELFSection(".hsadata_global_program",
+                                               ELF::SHT_PROGBITS,
+                                               ELF::SHF_ALLOC |
+                                               ELF::SHF_WRITE |
+                                               ELF::SHF_AMDGPU_HSA_GLOBAL);
 }
 
 
 static bool isModuleLinkage(const GlobalValue *GV) {
   return GV->getLinkage() == GlobalValue::CommonLinkage;
 }
 
 MCSection *AMDGPUHSATargetObjectFile::SelectSectionForGlobal(
                                         const GlobalValue *GV, SectionKind Kind,
                                         Mangler &Mang,
                                         const TargetMachine &TM) const {
   if (Kind.isText() && !GV->hasComdat())
     return getTextSection();
 
   // isCommon means globally writeable with a zero initializer.
   if (Kind.isCommon() && isModuleLinkage(GV))
     return DataGlobalAgentSection;
 
   if (Kind.isReadOnly() && GV->hasInternalLinkage())
     return RodataReadonlyAgentSection;
 
+  if (GV->hasExternalLinkage())
+    return DataGlobalProgramSection;
+
   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, Mang, TM);
 }

lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCAsmInfo.cpp

AMDGPUMCAsmInfo::AMDGPUMCAsmInfo(const Triple &TT) : MCAsmInfoELF() {
   HasNoDeadStrip = true;
   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" ||
          MCAsmInfo::shouldOmitSectionDirective(SectionName);
 }

lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h

virtual void EmitDirectiveHSACodeObjectISA(uint32_t Major, uint32_t Minor,
                                              StringRef VendorName,
                                              StringRef ArchName) = 0;
 
   virtual void EmitAMDKernelCodeT(const amd_kernel_code_t &Header) = 0;
 
   virtual void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) = 0;
 
   virtual void EmitAMDGPUHsaModuleGlobal(StringRef GlobalName) = 0;
+
+  virtual void EmitAMDGPUHsaProgramGlobal(StringRef GlobalName) = 0;
 };
 
 class AMDGPUTargetAsmStreamer : public AMDGPUTargetStreamer {
   formatted_raw_ostream &OS;
 public:
   AMDGPUTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
   void EmitDirectiveHSACodeObjectVersion(uint32_t Major,
                                          uint32_t Minor) override;
 
   void EmitDirectiveHSACodeObjectISA(uint32_t Major, uint32_t Minor,
                                      uint32_t Stepping, StringRef VendorName,
                                      StringRef ArchName) override;
 
   void EmitAMDKernelCodeT(const amd_kernel_code_t &Header) override;
 
   void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) override;
 
   void EmitAMDGPUHsaModuleGlobal(StringRef GlobalName) override;
+
+  void EmitAMDGPUHsaProgramGlobal(StringRef GlobalName) override;
 };
 
 class AMDGPUTargetELFStreamer : public AMDGPUTargetStreamer {
 
   enum NoteType {
     NT_AMDGPU_HSA_CODE_OBJECT_VERSION = 1,
     NT_AMDGPU_HSA_HSAIL = 2,
     NT_AMDGPU_HSA_ISA = 3,
void EmitDirectiveHSACodeObjectISA(uint32_t Major, uint32_t Minor,
                                      uint32_t Stepping, StringRef VendorName,
                                      StringRef ArchName) override;
 
   void EmitAMDKernelCodeT(const amd_kernel_code_t &Header) override;
 
   void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) override;
 
   void EmitAMDGPUHsaModuleGlobal(StringRef GlobalName) override;
+
+  void EmitAMDGPUHsaProgramGlobal(StringRef GlobalName) override;
 };
 
 }
 #endif

lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp

case ELF::STT_AMDGPU_HSA_KERNEL:
       break;
   }
 }
 
 void AMDGPUTargetAsmStreamer::EmitAMDGPUHsaModuleGlobal(StringRef GlobalName) {
   OS << "\t.amdgpu_hsa_module_global " << GlobalName << '\n';
 }
 
+void AMDGPUTargetAsmStreamer::EmitAMDGPUHsaProgramGlobal(StringRef GlobalName) {
+  OS << "\t.amdgpu_hsa_program_global " << GlobalName << '\n';
+}
+
 //===----------------------------------------------------------------------===//
 // AMDGPUTargetELFStreamer
 //===----------------------------------------------------------------------===//
 
 AMDGPUTargetELFStreamer::AMDGPUTargetELFStreamer(MCStreamer &S)
     : AMDGPUTargetStreamer(S), Streamer(S) { }
 
 MCELFStreamer &AMDGPUTargetELFStreamer::getStreamer() {

 }
 
 void AMDGPUTargetELFStreamer::EmitAMDGPUHsaModuleGlobal(StringRef GlobalName) {
 
   MCSymbolELF *Symbol = cast<MCSymbolELF>(
       getStreamer().getContext().getOrCreateSymbol(GlobalName));
   Symbol->setType(ELF::STT_OBJECT);
 }
+
+void AMDGPUTargetELFStreamer::EmitAMDGPUHsaProgramGlobal(StringRef GlobalName) {
+
+  MCSymbolELF *Symbol = cast<MCSymbolELF>(
+      getStreamer().getContext().getOrCreateSymbol(GlobalName));
+  Symbol->setType(ELF::STT_OBJECT);
+  Symbol->setBinding(ELF::STB_GLOBAL);
+}

test/CodeGen/AMDGPU/hsa-globals.ll

 ; RUN: llc < %s -mtriple=amdgcn--amdhsa -mcpu=kaveri | FileCheck --check-prefix=HSA-CI --check-prefix=HSA %s
 ; RUN: llc < %s -mtriple=amdgcn--amdhsa -mcpu=carrizo | FileCheck --check-prefix=HSA-VI --check-prefix=HSA %s
 ; RUN: llc < %s -mtriple=amdgcn--amdhsa -mcpu=kaveri -filetype=obj  | llvm-readobj -symbols -s -sd -relocations | FileCheck --check-prefix=ELF %s
 
 ; FIXME: Add assembler support for globals and relocations
 ; FIXME-XUN: llc < %s -mtriple=amdgcn--amdhsa -mcpu=kaveri | llvm-mc -filetype=obj -triple amdgcn--amdhsa -mcpu=kaveri | llvm-readobj -symbols -s -sd -relocations | FileCheck %s --check-prefix=ELF
 
 @const_array = internal unnamed_addr addrspace(2) constant [64 x i8] c"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<>", align 1
+@global_program = addrspace(1) global i32 0, align 4
 
 ; 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: Relocations [
 ; ELF: Section ({{[0-9]+}}) .rel.hsatext {
 ; ELF-DAG: R_AMDGPU_32_LO const_array
 ; ELF-DAG: R_AMDGPU_32_HI const_array
 ; ELF: }
 
 ; ELF: Symbol {
 ; ELF: Name: const_array
 ; ELF: Binding: Local (0x0)
 ; ELF: Type: Object (0x1)
 ; ELF: Section: .hsarodata_readonly_agent (0x6)
 ; ELF: }
 
+; ELF: Symbol {
+; ELF: Name: global_program
+; ELF: Binding: Global (0x1)
+; ELF: Type: Object (0x1)
+; ELF: Section: .hsadata_global_program
+; ELF: }
+
 ; HSA-LABEL: {{^}}test:
 ; HSA-DAG: s_mov_b32 s[[LORELOC:[0-9]+]], const_array@LO
 ; HSA-DAG: s_mov_b32 s[[HIRELOC:[0-9]+]], const_array@HI
 ; HSA-VI: s_add_u32 s[[SPTRLO:[0-9]+]], s[[LORELOC]], s{{[0-9]+}}
 ; HSA-VI: s_addc_u32 s[[SPTRHI:[0-9]+]], s[[HIRELOC]], s{{[0-9]+}}
 ; HSA-VI-DAG: v_mov_b32_e32 v[[VPTRLO:[0-9]+]], s[[SPTRLO]]
 ; HSA-VI-DAG: v_mov_b32_e32 v[[VPTRHI:[0-9]+]], s[[SPTRHI]]
 ; HSA-VI: flat_load_ubyte v{{[0-9]+}}, v{{\[}}[[VPTRLO]]:[[VPTRHI]]{{\]}}
 ; HSA-CI: buffer_load_ubyte v{{[0-9]+}}, v[{{[0-9]+}}:{{[0-9]+}}], s{{\[}}[[LORELOC]]:{{[0-9]+}}]
 ; HSA: s_endpgm
 ; HSA: .amdgpu_hsa_module_global const_array
 ; HSA: .hsarodata_readonly_agent
 ; HSA: const_array:
 ; HSA: .ascii  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<>"
+; HSA: .hsadata_global_program
+; HSA: global_program:
+; HSA: .long 0
 
 ; HSA-NOT: EndOfTextLabel
 define void @test(i8 addrspace(1) *%out, i32 %offset) {
 entry:
   %ptr = getelementptr [64 x i8], [64 x i8] addrspace(2)* @const_array, i32 0, i32 %offset
 ;  %0 = getelementptr inbounds [2 x i32], [2 x i32] addrspace(3)* @local_mem, i32 0, i32 %index
   %val = load i8, i8 addrspace(2)* %ptr
   store i8 %val, i8 addrspace(1)* %out
   ret void
 }