Remap metadata attached to global variables.

[eugenis]

Summary

Fix for PR32577.
Global variables may have !associated metadata, which includes a reference to another global, and needs remapping.

[pcc]

LGTM

We were probably getting lucky with other metadata attachments for globals (e.g. !dbg), presumably these would need to be mapped as well if a global reference was reachable from DIGlobalVariable (I was under the impression that this was still possible with templates in some cases, but maybe this has been fixed -- @dexonsmith?).

[dexonsmith]

This LGTM too.

I'm not sure if globals are still reachable via !dbg, but it certainly used to be possible. Adrian, do you know the current state?

[dexonsmith]

(I must have misclicked somewhere.)

[aprantl]

I'm not sure if globals are still reachable via !dbg, but it certainly used to be possible. Adrian, do you know the current state?

I'm not sure I understand your question:

Global variables can either be described as !dbg attachments to globals:

@a = global i32, !dbg !0
!0 = !DIGlobalVariableExpression(var: DIGlobalVariable(name: "a"...))

or via a DICompileUnit:

!0 = DICompileUnit(..., globals: !{!1})
!1 = !DIGlobalVariableExpression(var: DIGlobalVariable(name: "my_const", expr: DIExpression(DW_OP_constu, 23)))

LLVM globals cannot be referenced from metadata any more if that is what you meant.

[eugenis]

r302203

lib/Transforms/Utils/ValueMapper.cpp

public:
   registerAlternateMappingContext(ValueToValueMapTy &VM,
                                   ValueMaterializer *Materializer = nullptr) {
     MCs.push_back(MappingContext(VM, Materializer));
     return MCs.size() - 1;
   }
 
   void addFlags(RemapFlags Flags);
 
+  void remapGlobalObjectMetadata(GlobalObject &GO);
+
   Value *mapValue(const Value *V);
   void remapInstruction(Instruction *I);
   void remapFunction(Function &F);
 
   Constant *mapConstant(const Constant *C) {
     return cast_or_null<Constant>(mapValue(C));
   }
 

 void Mapper::flush() {
   // Flush out the worklist of global values.
   while (!Worklist.empty()) {
     WorklistEntry E = Worklist.pop_back_val();
     CurrentMCID = E.MCID;
     switch (E.Kind) {
     case WorklistEntry::MapGlobalInit:
       E.Data.GVInit.GV->setInitializer(mapConstant(E.Data.GVInit.Init));
+      remapGlobalObjectMetadata(*E.Data.GVInit.GV);
       break;
     case WorklistEntry::MapAppendingVar: {
       unsigned PrefixSize = AppendingInits.size() - E.AppendingGVNumNewMembers;
       mapAppendingVariable(*E.Data.AppendingGV.GV,
                            E.Data.AppendingGV.InitPrefix,
                            E.AppendingGVIsOldCtorDtor,
                            makeArrayRef(AppendingInits).slice(PrefixSize));
       AppendingInits.resize(PrefixSize);
if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
     GEP->setSourceElementType(
         TypeMapper->remapType(GEP->getSourceElementType()));
     GEP->setResultElementType(
         TypeMapper->remapType(GEP->getResultElementType()));
   }
   I->mutateType(TypeMapper->remapType(I->getType()));
 }
 
+void Mapper::remapGlobalObjectMetadata(GlobalObject &GO) {
+  SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
+  GO.getAllMetadata(MDs);
+  GO.clearMetadata();
+  for (const auto &I : MDs)
+    GO.addMetadata(I.first, *cast<MDNode>(mapMetadata(I.second)));
+}
+
 void Mapper::remapFunction(Function &F) {
   // Remap the operands.
   for (Use &Op : F.operands())
     if (Op)
       Op = mapValue(Op);
 
   // Remap the metadata attachments.
-  SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
-  F.getAllMetadata(MDs);
-  F.clearMetadata();
-  for (const auto &I : MDs)
-    F.addMetadata(I.first, *cast<MDNode>(mapMetadata(I.second)));
+  remapGlobalObjectMetadata(F);
 
   // Remap the argument types.
   if (TypeMapper)
     for (Argument &A : F.args())
       A.mutateType(TypeMapper->remapType(A.getType()));
 
   // Remap the instructions.
   for (BasicBlock &BB : F)

test/Linker/metadata-global.ll

+; RUN: llvm-link %s -S | FileCheck %s
+
+; CHECK-DAG: @a = global i32 0
+; CHECK-DAG: @b = global i32 0, !associated !0
+
+; CHECK-DAG: !0 = !{i32* @b}
+
+@a = global i32 0
+@b = global i32 0, !associated !0
+
+!0 = !{i32* @b}