[OpenMP] Make offloading sections have the SHF_EXCLUDE flag

[jhuber6]

Summary

Offloading sections can be embedded in the host during codegen via a
section. This section was originally marked as metadata to prevent it
from being loaded, but these sections are completely unused at runtime
so the linker should automatically drop them from the final executable
or shard library. This flag adds support for the SHF_EXCLUDE flag in
target lowering and uses it.

[JonChesterfield]

I think we need tests for coff and elf for the MC part, should be existing ones for the other flags. Ideal fit for the openmp sectiy, good find. Inclined to ignore the formatting warnings on old code.

[jhuber6]

Adding COFF test.

[jhuber6]

ping

[JonChesterfield]

Thanks for the extra test lines!

[MaskRay]

llvm/include/llvm/MC/SectionKind.h

27

https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments "Don’t duplicate function or class name at the beginning of the comment."

It may help to add "(ELF specific)".

[jhuber6]

llvm/include/llvm/MC/SectionKind.h

27

Yes, this only works for COFF and ELF so that should probably be documented. As for the style I'm just keeping it consistent with what's already here. I could make a follow-up patch to clean it but I figured it would add unnecessary noise to this one.

[MaskRay]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

452

getMetadata() | getExclude().

SHF_EXCLUDE is orthogonal to SHF_ALLOC.

[jhuber6]

Making suggested changes.

[MaskRay]

llvm/test/CodeGen/X86/offload_sections.ll

7–8

Remove -DAG. There is no other line for testing.

If there is other stuff after "e", check that. If there isn't any, append {{$}}

llvm/include/llvm/MC/SectionKind.h

 /// The comments below describe these as if they were an inheritance hierarchy
 /// in order to explain the predicates below.
 ///
 class SectionKind {
   enum Kind {
     /// Metadata - Debug info sections or other metadata.
     Metadata,
 
+    /// Exclude - This section will be excluded from the final executable or
+    /// shared library. Only valid for ELF / COFF targets.
+    Exclude,
+
     /// Text - Text section, used for functions and other executable code.
     Text,
 
            /// ExecuteOnly, Text section that is not readable.
            ExecuteOnly,
 
     /// ReadOnly - Data that is never written to at program runtime by the
     /// program or the dynamic linker.  Things in the top-level readonly
/// to during program runtime.
            /// mark the pages these globals end up on as read-only after it is
            /// done with its relocation phase.
            ReadOnlyWithRel
   } K : 8;
 public:
 
   bool isMetadata() const { return K == Metadata; }
 
+  bool isExclude() const { return K == Exclude; }
+
   bool isText() const { return K == Text || K == ExecuteOnly; }
 
   bool isExecuteOnly() const { return K == ExecuteOnly; }
 
   bool isReadOnly() const {
     return K == ReadOnly || isMergeableCString() ||
            isMergeableConst();
   }
private:
   static SectionKind get(Kind K) {
     SectionKind Res;
     Res.K = K;
     return Res;
   }
 public:
 
   static SectionKind getMetadata() { return get(Metadata); }
+  static SectionKind getExclude() { return get(Exclude); }
   static SectionKind getText() { return get(Text); }
   static SectionKind getExecuteOnly() { return get(ExecuteOnly); }
   static SectionKind getReadOnly() { return get(ReadOnly); }
   static SectionKind getMergeable1ByteCString() {
     return get(Mergeable1ByteCString);
   }
   static SectionKind getMergeable2ByteCString() {
     return get(Mergeable2ByteCString);

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
   // section(".eh_frame") gcc will produce:
   //
   //   .section   .eh_frame,"a",@progbits
 
   if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
                                       /*AddSegmentInfo=*/false) ||
       Name == getInstrProfSectionName(IPSK_covfun, Triple::ELF,
                                       /*AddSegmentInfo=*/false) ||
-      Name == ".llvmbc" || Name == ".llvmcmd" ||
-      Name.startswith(".llvm.offloading."))
+      Name == ".llvmbc" || Name == ".llvmcmd")
     return SectionKind::getMetadata();
 
+  if (Name.startswith(".llvm.offloading"))
+    return SectionKind::getExclude();
+
   if (Name.empty() || Name[0] != '.') return K;
 
   // Default implementation based on some magic section names.
   if (Name == ".bss" ||
       Name.startswith(".bss.") ||
       Name.startswith(".gnu.linkonce.b.") ||
       Name.startswith(".llvm.linkonce.b.") ||
       Name == ".sbss" ||
if (K.isBSS() || K.isThreadBSS())
     return ELF::SHT_NOBITS;
 
   return ELF::SHT_PROGBITS;
 }
 
 static unsigned getELFSectionFlags(SectionKind K) {
   unsigned Flags = 0;
 
-  if (!K.isMetadata())
+  if (!K.isMetadata() && !K.isExclude())
     Flags |= ELF::SHF_ALLOC;
 
+  if (K.isExclude())
+    Flags |= ELF::SHF_EXCLUDE;
+
   if (K.isText())
     Flags |= ELF::SHF_EXECINSTR;
 
   if (K.isExecuteOnly())
     Flags |= ELF::SHF_ARM_PURECODE;
 
   if (K.isWriteable())
     Flags |= ELF::SHF_WRITE;

 static unsigned
 getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) {
   unsigned Flags = 0;
   bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
 
   if (K.isMetadata())
     Flags |=
       COFF::IMAGE_SCN_MEM_DISCARDABLE;
+  else if (K.isExclude())
+    Flags |=
+      COFF::IMAGE_SCN_LNK_REMOVE | COFF::IMAGE_SCN_MEM_DISCARDABLE;
   else if (K.isText())
     Flags |=
       COFF::IMAGE_SCN_MEM_EXECUTE |
       COFF::IMAGE_SCN_MEM_READ |
       COFF::IMAGE_SCN_CNT_CODE |
       (isThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0);
   else if (K.isBSS())
     Flags |=

llvm/test/CodeGen/X86/offload_sections.ll

-; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
+; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s --check-prefix=CHECK-ELF
+; RUN: llc < %s -mtriple=x86_64-win32-gnu | FileCheck %s --check-prefix=CHECK-COFF
 
[e-mail] = hidden constant [1 x i8] c"\00", section ".llvm.offloading.dummy"
[e-mail] = private constant [1 x i8] c"\00", section ".llvm.offloading"
 @llvm.compiler.used = appending global [1 x i8*] [i8* getelementptr inbounds ([1 x i8], [1 x i8]* @llvm.embedded.object, i32 0, i32 0)], section "llvm.metadata"
 
-; CHECK-DAG: .section .llvm.offloading.dummy,""
+; CHECK-ELF: .section .llvm.offloading,"e"
+; CHECK-COFF: .section  .llvm.offloading,"dr"