LangRef: Add !associated to list of preserved global metadata

[arsenm]

Accidental diff

[MaskRay]

LGTM.

[arsenm]

50b18d4140cf10c1bb5aeac6a89eab5d840853d5

llvm/docs/LangRef.rst

.. code-block:: llvm
     }
 
     @g1 = global i32 0, !dbg !22
     @g2 = external global i32, !dbg !22
 
 Unlike instructions, global objects (functions and global variables) may have
 multiple metadata attachments with the same identifier.
 
-A transformation is required to drop any metadata attachment that it does not
-know or know it can't preserve. Currently there is an exception for metadata
-attachment to globals for ``!func_sanitize``, ``!type`` and ``!absolute_symbol`` which can't be
+A transformation is required to drop any metadata attachment that it
+does not know or know it can't preserve. Currently there is an
+exception for metadata attachment to globals for ``!func_sanitize``,
+``!type``, ``!absolute_symbol`` and ``!associated`` which can't be
 unconditionally dropped unless the global is itself deleted.
 
 Metadata attached to a module using named metadata may not be dropped, with
 the exception of debug metadata (named metadata with the name ``!llvm.dbg.*``).
 
 More information about specific metadata nodes recognized by the
 optimizers and code generator is found below.
 

llvm/lib/IR/Verifier.cpp

if (MaybeAlign A = GO->getAlign()) {
             "huge alignment values are unsupported", GO);
     }
 
     if (const MDNode *Associated =
             GO->getMetadata(LLVMContext::MD_associated)) {
       Check(Associated->getNumOperands() == 1,
             "associated metadata must have one operand", &GV, Associated);
       const Metadata *Op = Associated->getOperand(0).get();
-      Check(Op, "missing associated global", GO, Associated);
+      Check(Op, "associated metadata must have a global value", GO, Associated);
 
       const auto *VM = dyn_cast_or_null<ValueAsMetadata>(Op);
       Check(VM, "associated metadata must be ValueAsMetadata", GO,
             Associated);
       if (VM) {
         Check(isa<PointerType>(VM->getValue()->getType()),
               "associated value must be pointer typed", GV, Associated);
 
         const Value *Stripped = VM->getValue()->stripPointerCastsAndAliases();
         Check(isa<GlobalObject>(Stripped) || isa<Constant>(Stripped),
               "associated metadata must point to a GlobalObject", GO,
               Stripped);
+        Check(Stripped != VM->getValue(),
+              "global values should not associate to themselves", GO,
+              Associated);
       }
     }
   }
   Check(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
         "Only global variables can have appending linkage!", &GV);
 
   if (GV.hasAppendingLinkage()) {
     const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);

llvm/test/Verifier/associated-metadata.ll

 ; CHECK-NEXT: !2 = !{ptr @gv.decl0, ptr @gv.decl1}
 @associated.too.many.ops = external addrspace(1) constant [8 x i8], !associated !2
 
 ; CHECK: associated metadata must have one operand
 ; CHECK-NEXT: ptr addrspace(1) @associated.empty
 ; CHECK-NEXT: !3 = !{}
 @associated.empty = external addrspace(1) constant [8 x i8], !associated !3
 
+; CHECK: associated metadata must have a global value
+; CHECK-NEXT: ptr addrspace(1) @associated.null.metadata
+; CHECK-NEXT: !4 = !{null}
[e-mail] = external addrspace(1) constant [8 x i8], !associated !4
+
+; CHECK: global values should not associate to themselves
+; CHECK-NEXT: ptr @associated.self
+; CHECK-NEXT: !5 = !{ptr @associated.self}
[e-mail] = external constant [8 x i8], !associated !5
+
 @gv.decl0 = external constant [8 x i8]
 @gv.decl1 = external constant [8 x i8]
 
 !0 = !{i32 1}
 !1 = !{float 1.000000e+00}
 !2 = !{ptr @gv.decl0, ptr @gv.decl1}
 !3 = !{}
+!4 = !{null}
+!5 = !{ptr @associated.self}