[Metadata] Add 'exclude' metadata to add the exclude flags on globals

[jhuber6]

Summary

This patchs adds a new metadata kind exclude which implies that the
global variable should be given the necessary flags during code
generation to not be included in the final executable. This is done
using the `SHF_EXCLUDE` flag on ELF for example. This should make it
easier to specify this flag on a variable without needing to explicitly
check the section name in the target backend.

Depends on D129053 D129052

[MaskRay]

llvm/test/CodeGen/X86/offload_sections.ll

1

!associated tests may give insight how to add more cases.

[jhuber6]

Adding more tests

[jhenderson]

Spotted a couple of minor issues in the docs, but otherwise, I don't have the knowledge to review this.

llvm/docs/LangRef.rst

6400

Nit: the underline is too long here, and will probably cause a doc build warning.

6405

[jdoerfert]

llvm/docs/LangRef.rst

6411

The argument (!0) is not described.

llvm/lib/Transforms/Utils/ModuleUtils.cpp

284

Test this in the files that should be affected.

llvm/test/CodeGen/X86/offload_sections.ll

7

Unclear why exclude references the embedded object metadata here. What does that mean?

[jhuber6]

Addressing comments. Metadata is now empty and must be empty for the flag to be emitted.

[jdoerfert]

LG

clang/test/Frontend/embed-object.c

 // RUN: %clang_cc1 -x c -triple x86_64-unknown-linux-gnu -emit-llvm -fembed-offload-object=%S/Inputs/empty.h -o - %s | FileCheck %s
 
-// CHECK: @[[OBJECT:.+]] = private constant [0 x i8] zeroinitializer, section ".llvm.offloading", align 8
+// CHECK: @[[OBJECT:.+]] = private constant [0 x i8] zeroinitializer, section ".llvm.offloading", align 8, !exclude
 // CHECK: @llvm.compiler.used = appending global [1 x ptr] [ptr @[[OBJECT]]], section "llvm.metadata"
 
 void foo(void) {}
 
 // CHECK: !llvm.embedded.objects = !{![[METADATA:[0-9]+]]}
 // CHECK: ![[METADATA]] = !{ptr @[[OBJECT]], !".llvm.offloading"}

clang/test/Frontend/embed-object.ll

 ; RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm \
 ; RUN:    -fembed-offload-object=%S/Inputs/empty.h \
 ; RUN:    -fembed-offload-object=%S/Inputs/empty.h -x ir %s -o - \
 ; RUN:    | FileCheck %s -check-prefix=CHECK
 
-; CHECK: @[[OBJECT_1:.+]] = private constant [0 x i8] zeroinitializer, section ".llvm.offloading", align 8
-; CHECK: @[[OBJECT_2:.+]] = private constant [0 x i8] zeroinitializer, section ".llvm.offloading", align 8
+; CHECK: @[[OBJECT_1:.+]] = private constant [0 x i8] zeroinitializer, section ".llvm.offloading", align 8, !exclude
+; CHECK: @[[OBJECT_2:.+]] = private constant [0 x i8] zeroinitializer, section ".llvm.offloading", align 8, !exclude
 ; CHECK: @llvm.compiler.used = appending global [3 x ptr] [ptr @x, ptr @[[OBJECT_1]], ptr @[[OBJECT_2]]], section "llvm.metadata"
 
 @x = private constant i8 1
 @llvm.compiler.used = appending global [1 x ptr] [ptr @x], section "llvm.metadata"
 
 define i32 @foo() {
   ret i32 0
 }
 
 ; CHECK: !llvm.embedded.objects = !{![[METADATA_1:[0-9]+]], ![[METADATA_2:[0-9]+]]}
 ; CHECK: ![[METADATA_1]] = !{ptr @[[OBJECT_1]], !".llvm.offloading"}
 ; CHECK: ![[METADATA_2]] = !{ptr @[[OBJECT_2]], !".llvm.offloading"}

llvm/docs/LangRef.rst

 .. code-block:: text
 
     declare !callback !0 dso_local void @__kmpc_fork_call(%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...)
 
     ...
     !1 = !{i64 2, i64 -1, i64 -1, i1 true}
     !0 = !{!1}
 
+'``exclude``' Metadata
+^^^^^^^^^^^^^^^^^^^^^^
+
+``exclude`` metadata may be attached to a global variable to signify that its
+section should not be included in the final executable or shared library. This
+option is only valid for global variables with an explicit section targeting ELF
+or COFF. This is done using the ``SHF_EXCLUDE`` flag on ELF targets and the
+``IMAGE_SCN_LNK_REMOVE`` and ``IMAGE_SCN_MEM_DISCARDABLE`` flags for COFF
+targets. Additionally, this metadata is only used as a flag, so the associated
+node must be empty. The explicit section should not conflict with any other
+sections that the user does not want removed after linking.
+
+.. code-block:: text
+
+  @object = private constant [1 x i8] c"\00", section ".foo" !exclude !0
+
+  ...
+  !0 = !{}
 
 '``unpredictable``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``unpredictable`` metadata may be attached to any branch or switch
 instruction. It can be used to express the unpredictability of control
 flow. Similar to the llvm.expect intrinsic, it may be used to alter
 optimizations related to compare and branch instructions. The metadata

llvm/include/llvm/IR/FixedMetadataKinds.def

 LLVM_FIXED_MD_KIND(MD_access_group, "llvm.access.group", 25)
 LLVM_FIXED_MD_KIND(MD_callback, "callback", 26)
 LLVM_FIXED_MD_KIND(MD_preserve_access_index, "llvm.preserve.access.index", 27)
 LLVM_FIXED_MD_KIND(MD_vcall_visibility, "vcall_visibility", 28)
 LLVM_FIXED_MD_KIND(MD_noundef, "noundef", 29)
 LLVM_FIXED_MD_KIND(MD_annotation, "annotation", 30)
 LLVM_FIXED_MD_KIND(MD_nosanitize, "nosanitize", 31)
 LLVM_FIXED_MD_KIND(MD_func_sanitize, "func_sanitize", 32)
+LLVM_FIXED_MD_KIND(MD_exclude, "exclude", 33)

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
 
   if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
                                       /*AddSegmentInfo=*/false) ||
       Name == getInstrProfSectionName(IPSK_covfun, Triple::ELF,
                                       /*AddSegmentInfo=*/false) ||
       Name == ".llvmbc" || Name == ".llvmcmd")
     return SectionKind::getMetadata();
 
-  if (Name == ".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" ||

llvm/lib/Target/TargetLoweringObjectFile.cpp

SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO,
   if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS) {
     if (GVar->hasLocalLinkage())
       return SectionKind::getBSSLocal();
     else if (GVar->hasExternalLinkage())
       return SectionKind::getBSSExtern();
     return SectionKind::getBSS();
   }
 
+  // Global variables with '!exclude' should get the exclude section kind if
+  // they have an explicit section and no other metadata.
+  if (GVar->hasSection())
+    if (MDNode *MD = GVar->getMetadata(LLVMContext::MD_exclude))
+      if (!MD->getNumOperands())
+        return SectionKind::getExclude();
+
   // If the global is marked constant, we can put it into a mergable section,
   // a mergable string section, or general .data if it contains relocations.
   if (GVar->isConstant()) {
     // If the initializer for the global contains something that requires a
     // relocation, then we may have to drop this into a writable data section
     // even though it is marked const.
     const Constant *C = GVar->getInitializer();
     if (!C->needsRelocation()) {

llvm/lib/Transforms/Utils/ModuleUtils.cpp

void llvm::embedBufferInModule(Module &M, MemoryBufferRef Buf,
   GV->setAlignment(Alignment);
 
   LLVMContext &Ctx = M.getContext();
   NamedMDNode *MD = M.getOrInsertNamedMetadata("llvm.embedded.objects");
   Metadata *MDVals[] = {ConstantAsMetadata::get(GV),
                         MDString::get(Ctx, SectionName)};
 
   MD->addOperand(llvm::MDNode::get(Ctx, MDVals));
+  GV->setMetadata(LLVMContext::MD_exclude, llvm::MDNode::get(Ctx, {}));
 
   appendToCompilerUsed(M, GV);
 }

llvm/test/CodeGen/X86/coff-exclude.ll

+; RUN: llc -mtriple x86_64-win32-gnu < %s | FileCheck %s
+
+@a = global i32 1
+@b = global i32 1, !exclude !0
+@c = global i32 1, section "aaa"
+; CHECK-DAG: c
+; CHECK-DAG:  .section  aaa,"dw"
+@d = global i32 1, section "bbb", !exclude !0
+; CHECK-DAG: d
+; CHECK-DAG:  .section  bbb,"ynD"
+@e = global i32 1, section "bbb", !exclude !0
+; CHECK-DAG: e
+@f = global i32 1, section "ccc", !exclude !0
+@g = global i32 1, section "ccc"
+; CHECK-DAG: f
+; CHECK-DAG:  .section  ccc,"ynD"
+
+!0 = !{}

llvm/test/CodeGen/X86/elf-exclude.ll

+; RUN: llc -mtriple x86_64-pc-linux-gnu < %s | FileCheck %s
+
+@a = global i32 1
+@b = global i32 1, !exclude !0
+@c = global i32 1, section "aaa"
+; CHECK-DAG: .type  c,@object
+; CHECK-DAG:  .section  aaa,"aw",@progbits
+@d = global i32 1, section "bbb", !exclude !0
+; CHECK-DAG: .type  d,@object
+; CHECK-DAG:  .section  bbb,"e",@progbits
+@e = global i32 1, section "bbb", !exclude !0
+; CHECK-DAG: .type  e,@object
+@f = global i32 1, section "ccc", !exclude !0
+@g = global i32 1, section "ccc"
+; CHECK-DAG:  .type f,@object
+; CHECK-DAG:  .section  ccc,"e",@progbits
+
+!0 = !{}

llvm/test/CodeGen/X86/offload_sections.ll

 ; 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] = private constant [1 x i8] c"\00", section ".llvm.offloading"
[e-mail] = private constant [1 x i8] c"\00", section ".llvm.offloading", align 8, !exclude !0
 @llvm.compiler.used = appending global [1 x ptr] [ptr @llvm.embedded.object], section "llvm.metadata"
 
+!0 = !{}
+
 ; CHECK-ELF: .section .llvm.offloading,"e",@llvm_offloading
-; CHECK-COFF: .section  .llvm.offloading,"dr"
+; CHECK-COFF: .section  .llvm.offloading,"ynD"