AMDGPU: Add support for .hsarodata_readonly_agent section

lib/ReaderWriter/ELF/AMDGPU/AMDGPUELFFile.cpp

ELFDefinedAtom<ELF64LE> *AMDGPUELFFile::createDefinedAtom(
     unsigned int referenceStart, unsigned int referenceEnd,
     std::vector<ELFReference<ELF64LE> *> &referenceList) {
 
   // The st_value field in the symbol table for symbols in the .hsatext
   // section must be section relative, so we need to store the original
   // symbol offset, which is section relative, so we can write it to the
   // symbol table in AMDDGPUSymbolTable::finalize().
   bool HasSectionRelativeOffset = false;
-  if (sectionName == ".hsatext")
+  if (sectionName == ".hsatext" || sectionName == ".hsarodata_readonly_agent")
     HasSectionRelativeOffset = true;
 
   return new (this->_readerStorage) AMDGPUELFDefinedAtom(
       *this, symName, sectionName, sym, sectionHdr, contentData, referenceStart,
       referenceEnd, referenceList, HasSectionRelativeOffset);
 }
 
 } // elf
 } // lld

lib/ReaderWriter/ELF/AMDGPU/AMDGPUSectionChunks.h

+//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUSectionChunks.h ------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLD_READER_WRITER_ELF_AMDGPU_AMDGPU_SECTION_CHUNKS_H
+#define LLD_READER_WRITER_ELF_AMDGPU_AMDGPU_SECTION_CHUNKS_H
+
+#include "TargetLayout.h"
+#include "SectionChunks.h"
+
+namespace lld {
+namespace elf {
+
+class HSARoDataReadOnlySection : public AtomSection<ELF64LE> {
+public:
+  HSARoDataReadOnlySection(const ELFLinkingContext &ctx);
+};
+
+} // elf
+} // lld
+
+#endif

lib/ReaderWriter/ELF/AMDGPU/AMDGPUSectionChunks.cpp

+//===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUSectionChunks.cpp ----------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AMDGPUSectionChunks.h"
+#include "AMDGPUELFFile.h"
+
+namespace lld {
+namespace elf {
+
+HSARoDataReadOnlySection::HSARoDataReadOnlySection(const ELFLinkingContext &ctx)
+    : AtomSection(ctx, ".hsarodata_readonly_agent", DefinedAtom::typeConstant,
+                  0, 0) {
+
+  _type = llvm::ELF::SHT_PROGBITS;
+  _flags = llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_AMDGPU_HSA_READONLY |
+           llvm::ELF::SHF_AMDGPU_HSA_AGENT;
+
+  // FIXME: What is the correct alignment?
+  _alignment = 4;
+
+}
+
+} // elf
+} // lld

lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.h

 //===- lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.h ------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef AMDGPU_TARGET_HANDLER_H
 #define AMDGPU_TARGET_HANDLER_H
 
 #include "AMDGPUELFFile.h"
 #include "ELFReader.h"
 #include "AMDGPURelocationHandler.h"
+#include "AMDGPUSectionChunks.h"
 #include "TargetLayout.h"
 
 namespace lld {
 namespace elf {
 class AMDGPULinkingContext;
 
 class HSATextSection : public AtomSection<ELF64LE> {
 public:
public:
   /// \brief Gets or creates a section.
   AtomSection<ELF64LE> *
   createSection(StringRef name, int32_t contentType,
                 DefinedAtom::ContentPermissions contentPermissions,
                 TargetLayout::SectionOrder sectionOrder) override {
     if (name == ".hsatext")
       return new (_allocator) HSATextSection(_ctx);
 
+    if (name == ".hsarodata_readonly_agent")
+      return new (_allocator) HSARoDataReadOnlySection(_ctx);
+
     if (name == ".note")
       contentType = DefinedAtom::typeRONote;
 
     return TargetLayout::createSection(name, contentType, contentPermissions,
                                        sectionOrder);
   }
 };
 

lib/ReaderWriter/ELF/AMDGPU/AMDGPUTargetHandler.cpp

 }
 
 void AMDGPUTargetLayout::assignSectionsToSegments() {
 
   TargetLayout::assignSectionsToSegments();
   for (OutputSection<ELF64LE> *osi : _outputSections) {
     for (Section<ELF64LE> *section : osi->sections()) {
       StringRef InputSectionName = section->inputSectionName();
-      if (InputSectionName != ".hsatext")
-        continue;
-
-      auto *segment = new (_allocator) Segment<ELF64LE>(
+      if (InputSectionName == ".hsatext") {
+        Segment<ELF64LE> *segment = new (_allocator) Segment<ELF64LE>(
             _ctx, "PT_AMDGPU_HSA_LOAD_CODE_AGENT", PT_AMDGPU_HSA_LOAD_CODE_AGENT);
         _segments.push_back(segment);
         assert(segment);
         segment->append(section);
       }
+
+
+      if (InputSectionName == ".hsarodata_readonly_agent") {
+        Segment<ELF64LE> *segment = new (_allocator) Segment<ELF64LE>(_ctx,
+            "PT_AMDGPU_HSA_LOAD_READONLY_AGENT", PT_AMDGPU_HSA_LOAD_READONLY_AGENT);
+        _segments.push_back(segment);
+        segment->append(section);
+      }
+    }
   }
 }
 
 } // namespace elf
 } // namespace lld

lib/ReaderWriter/ELF/AMDGPU/CMakeLists.txt

 add_llvm_library(lldAMDGPUELFTarget
   AMDGPUELFFile.cpp
   AMDGPUExecutableWriter.cpp
   AMDGPULinkingContext.cpp
   AMDGPURelocationHandler.cpp
+  AMDGPUSectionChunks.cpp
   AMDGPUSymbolTable.cpp
   AMDGPUTargetHandler.cpp
   LINK_LIBS
     lldELF
     lldReaderWriter
     lldCore
     LLVMObject
     LLVMSupport
   )

test/elf/AMDGPU/hsa-sections.test

+# RUN: yaml2obj -format=elf %s > %t.obj
+# RUN: lld -flavor gnu -target amdgcn--hsa %t.obj -o %t.exe --noinhibit-exec
+# RUN: llvm-readobj -h -program-headers -s -symbols %t.exe | FileCheck %s
+
+# CHECK: Section {
+# CHECK: Name: .hsarodata_readonly_agent
+# CHECK: Type: SHT_PROGBITS
+# CHECK: Flags [ (0xA00002
+# CHECK: SHF_ALLOC (0x2)
+# CHECK: SHF_AMDGPU_HSA_AGENT (0x800000) 
+# CHECK: SHF_AMDGPU_HSA_READONLY (0x200000)
+# CHECK: ]
+# CHECK: }
+
+# CHECK: ProgramHeader {
+# CHECK: Type: PT_AMDGPU_HSA_LOAD_READONLY_AGENT (0x60000002)
+# CHECK: }
+
+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  OSABI:           ELFOSABI_GNU
+  Type:            ET_REL
+  Machine:         EM_AMDGPU
+Sections:
+  - Name: .hsarodata_readonly_agent
+    Type: SHT_PROGBITS
+    Flags: [ SHF_ALLOC, SHF_AMDGPU_HSA_AGENT, SHF_AMDGPU_HSA_READONLY ]
+...